diff options
Diffstat (limited to 'Lib/test')
118 files changed, 1873 insertions, 1874 deletions
diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py index db27759..d0d8a56 100644 --- a/Lib/test/buffer_tests.py +++ b/Lib/test/buffer_tests.py @@ -15,32 +15,32 @@ class MixinBytesBufferCommonTests(object): 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 @@ class MixinBytesBufferCommonTests(object): 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 @@ class MixinBytesBufferCommonTests(object): 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 cc51f89..2646cbd 100644 --- a/Lib/test/fork_wait.py +++ b/Lib/test/fork_wait.py @@ -43,8 +43,8 @@ class ForkWait(unittest.TestCase): 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): @@ -54,7 +54,7 @@ class ForkWait(unittest.TestCase): a = self.alive.keys() a.sort() - self.assertEquals(a, range(NUM_THREADS)) + self.assertEqual(a, range(NUM_THREADS)) prefork_lives = self.alive.copy() diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py index 546416e..b8d6d6b 100644 --- a/Lib/test/list_tests.py +++ b/Lib/test/list_tests.py @@ -330,7 +330,7 @@ class CommonTest(seq_tests.CommonTest): 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 @@ -466,7 +466,7 @@ class CommonTest(seq_tests.CommonTest): 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/seq_tests.py b/Lib/test/seq_tests.py index cf3ae8e..f5e4e0e 100644 --- a/Lib/test/seq_tests.py +++ b/Lib/test/seq_tests.py @@ -131,8 +131,8 @@ class CommonTest(unittest.TestCase): 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]) @@ -270,7 +270,7 @@ class CommonTest(unittest.TestCase): 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 eb5132e..546b486 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -62,7 +62,7 @@ class CommonTest(unittest.TestCase): pass object = subtype(object) realresult = getattr(object, methodname)(*args) - self.assert_(object is not realresult) + self.assertTrue(object is not realresult) # check that object.method(*args) raises exc def checkraises(self, exc, object, methodname, *args): @@ -1243,34 +1243,34 @@ class MixinStrUnicodeTest: pass s1 = subclass("abcd") s2 = t().join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is t) s1 = t("abcd") s2 = t().join([s1]) - self.assert_(s1 is s2) + self.assertTrue(s1 is s2) # Should also test mixed-type join. if t is unicode: s1 = subclass("abcd") s2 = "".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is t) s1 = t("abcd") s2 = "".join([s1]) - self.assert_(s1 is s2) + self.assertTrue(s1 is s2) elif t is str: s1 = subclass("abcd") s2 = u"".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is unicode) # promotes! + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is unicode) # promotes! s1 = t("abcd") s2 = u"".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is unicode) # promotes! + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is unicode) # 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 9d3ad16..66ec853 100644 --- a/Lib/test/test_SimpleHTTPServer.py +++ b/Lib/test/test_SimpleHTTPServer.py @@ -21,17 +21,17 @@ class SimpleHTTPRequestHandlerTestCase(unittest.TestCase): 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 2fc128f..afcb926 100644 --- a/Lib/test/test__locale.py +++ b/Lib/test/test__locale.py @@ -59,7 +59,7 @@ class _LocaleTests(unittest.TestCase): 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, @@ -103,7 +103,7 @@ class _LocaleTests(unittest.TestCase): 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, @@ -122,9 +122,9 @@ class _LocaleTests(unittest.TestCase): 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_argparse.py b/Lib/test/test_argparse.py index 17f4bb4..3e71f57 100644 --- a/Lib/test/test_argparse.py +++ b/Lib/test/test_argparse.py @@ -2709,18 +2709,18 @@ class TestNamespaceContainsSimple(TestCase): def test_empty(self): ns = argparse.Namespace() - self.assertEquals('' in ns, False) - self.assertEquals('' not in ns, True) - self.assertEquals('x' in ns, False) + self.assertEqual('' in ns, False) + self.assertEqual('' not in ns, True) + self.assertEqual('x' in ns, False) def test_non_empty(self): ns = argparse.Namespace(x=1, y=2) - self.assertEquals('x' in ns, True) - self.assertEquals('x' not in ns, False) - self.assertEquals('y' in ns, True) - self.assertEquals('' in ns, False) - self.assertEquals('xx' in ns, False) - self.assertEquals('z' in ns, False) + self.assertEqual('x' in ns, True) + self.assertEqual('x' not in ns, False) + self.assertEqual('y' in ns, True) + self.assertEqual('' in ns, False) + self.assertEqual('xx' in ns, False) + self.assertEqual('z' in ns, False) # ===================== # Help formatting tests diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py index a4aeccf..4d56f54 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -628,11 +628,11 @@ class BaseTest(unittest.TestCase): 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 2ee9d2a..05ce09e 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -147,7 +147,7 @@ class AST_Tests(unittest.TestCase): (eval_tests, eval_results, "eval")): for i, o in itertools.izip(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_slice(self): @@ -171,20 +171,20 @@ class AST_Tests(unittest.TestCase): 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() @@ -202,7 +202,7 @@ class AST_Tests(unittest.TestCase): 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)) class ASTHelpers_Test(unittest.TestCase): diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index 0292a95..059e8b7 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -19,10 +19,10 @@ class AugAssignTest(unittest.TestCase): x /= 2 if 1/2 == 0: # classic division - self.assertEquals(x, 3) + self.assertEqual(x, 3) else: # new-style division (with -Qnew) - self.assertEquals(x, 3.0) + self.assertEqual(x, 3.0) def test_with_unpacking(self): self.assertRaises(SyntaxError, compile, "x, b += 3", "<test>", "exec") @@ -40,9 +40,9 @@ class AugAssignTest(unittest.TestCase): x[0] ^= 1 x[0] /= 2 if 1/2 == 0: - self.assertEquals(x[0], 3) + self.assertEqual(x[0], 3) else: - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testInDict(self): x = {0: 2} @@ -57,23 +57,23 @@ class AugAssignTest(unittest.TestCase): x[0] ^= 1 x[0] /= 2 if 1/2 == 0: - self.assertEquals(x[0], 3) + self.assertEqual(x[0], 3) else: - 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): @@ -101,14 +101,14 @@ class AugAssignTest(unittest.TestCase): self.assertIsInstance(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 @@ -116,7 +116,7 @@ class AugAssignTest(unittest.TestCase): self.assertIsInstance(x, aug_test3) self.assertTrue(y is not x) - self.assertEquals(x.val, 13) + self.assertEqual(x.val, 13) def testCustomMethods2(test_self): @@ -284,7 +284,7 @@ class AugAssignTest(unittest.TestCase): 1 << x x <<= 1 - test_self.assertEquals(output, '''\ + test_self.assertEqual(output, '''\ __add__ called __radd__ called __iadd__ called diff --git a/Lib/test/test_bigaddrspace.py b/Lib/test/test_bigaddrspace.py index 8c215fe..db19a53 100644 --- a/Lib/test/test_bigaddrspace.py +++ b/Lib/test/test_bigaddrspace.py @@ -28,7 +28,7 @@ class StrTest(unittest.TestCase): pass else: self.fail("should have raised OverflowError") - self.assertEquals(len(x), MAX_Py_ssize_t) + self.assertEqual(len(x), MAX_Py_ssize_t) ### the following test is pending a patch # (http://mail.python.org/pipermail/python-dev/2006-July/067774.html) diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index 1f7fd6a..c560167 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -13,7 +13,7 @@ import sys # 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 # lengty 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. @@ -39,20 +39,20 @@ class StrTest(unittest.TestCase): SUBSTR = ' 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 = ' 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()) @precisionbigmemtest(size=_2G - 1, memuse=1) def test_center_unicode(self, size): @@ -62,36 +62,36 @@ class StrTest(unittest.TestCase): except OverflowError: pass # acceptable on 32-bit else: - 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()) del s @bigmemtest(minsize=_2G, memuse=2) def test_count(self, size): 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 + 2, memuse=3) def test_decode(self, size): s = '.' * size - self.assertEquals(len(s.decode('utf-8')), size) + self.assertEqual(len(s.decode('utf-8')), size) def basic_encode_test(self, size, enc, c=u'.', expectedsize=None): if expectedsize is None: expectedsize = size s = c * size - self.assertEquals(len(s.encode(enc)), expectedsize) + self.assertEqual(len(s.encode(enc)), expectedsize) @bigmemtest(minsize=_2G + 2, memuse=3) def test_encode(self, size): @@ -147,43 +147,43 @@ class StrTest(unittest.TestCase): def test_expandtabs(self, size): 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): 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): 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') @@ -252,8 +252,8 @@ class StrTest(unittest.TestCase): def test_join(self, size): 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')) @@ -262,25 +262,25 @@ class StrTest(unittest.TestCase): 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): 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): 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) stripped = s.lstrip() self.assertTrue(stripped is s) @@ -289,44 +289,44 @@ class StrTest(unittest.TestCase): 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): 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): SUBSTR = ' abc def ghi' sublen = len(SUBSTR) s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEquals(s.rindex(' '), + self.assertEqual(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(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) @@ -334,18 +334,18 @@ class StrTest(unittest.TestCase): 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): 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) stripped = s.rstrip() self.assertTrue(stripped is s) @@ -360,12 +360,12 @@ class StrTest(unittest.TestCase): SUBSTR = 'a' + ' ' * chunksize s = SUBSTR * chunksize l = s.split() - self.assertEquals(len(l), chunksize) - self.assertEquals(set(l), set(['a'])) + self.assertEqual(len(l), chunksize) + self.assertEqual(set(l), set(['a'])) del l l = s.split('a') - self.assertEquals(len(l), chunksize + 1) - self.assertEquals(set(l), set(['', ' ' * chunksize])) + self.assertEqual(len(l), chunksize + 1) + self.assertEqual(set(l), set(['', ' ' * chunksize])) # Allocates a string of twice size (and briefly two) and a list of # size. Because of internal affairs, the s.split() call produces a @@ -377,12 +377,12 @@ class StrTest(unittest.TestCase): def test_split_large(self, size): 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): @@ -392,8 +392,8 @@ class StrTest(unittest.TestCase): SUBSTR = ' ' * chunksize + '\n' + ' ' * chunksize + '\r\n' s = SUBSTR * chunksize l = s.splitlines() - self.assertEquals(len(l), chunksize * 2) - self.assertEquals(set(l), set([' ' * chunksize])) + self.assertEqual(len(l), chunksize * 2) + self.assertEqual(set(l), set([' ' * chunksize])) @bigmemtest(minsize=_2G, memuse=2) def test_startswith(self, size): @@ -407,12 +407,12 @@ class StrTest(unittest.TestCase): def test_strip(self, size): 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): @@ -421,9 +421,9 @@ class StrTest(unittest.TestCase): 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): @@ -441,19 +441,19 @@ class StrTest(unittest.TestCase): 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): 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): @@ -461,8 +461,8 @@ class StrTest(unittest.TestCase): 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)) @bigmemtest(minsize=_2G + 10, memuse=2) def test_format(self, size): @@ -471,7 +471,7 @@ class StrTest(unittest.TestCase): self.assertTrue(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 @@ -481,18 +481,18 @@ class StrTest(unittest.TestCase): 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=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 @@ -500,21 +500,21 @@ class StrTest(unittest.TestCase): 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=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=6+2) def test_unicode_repr(self, size): @@ -526,20 +526,20 @@ class StrTest(unittest.TestCase): @bigmemtest(minsize=_1G + 2, memuse=3) def test_concat(self, size): 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 :) @bigmemtest(minsize=_1G + 2, memuse=3) def test_repeat(self, size): 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=1) def test_slice_and_getitem(self, size): @@ -549,26 +549,26 @@ class StrTest(unittest.TestCase): 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) @@ -643,9 +643,9 @@ class TupleTest(unittest.TestCase): # 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): @@ -658,7 +658,7 @@ class TupleTest(unittest.TestCase): @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.assertIn(5, t) self.assertNotIn((1, 2, 3, 4, 5), t) self.assertNotIn(0, t) @@ -674,27 +674,27 @@ class TupleTest(unittest.TestCase): @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): @@ -717,9 +717,9 @@ class TupleTest(unittest.TestCase): 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): @@ -727,9 +727,9 @@ class TupleTest(unittest.TestCase): t = tuple(xrange(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 @@ -738,10 +738,10 @@ class TupleTest(unittest.TestCase): 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): @@ -777,9 +777,9 @@ class ListTest(unittest.TestCase): # 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): @@ -792,7 +792,7 @@ class ListTest(unittest.TestCase): 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]) @@ -807,7 +807,7 @@ class ListTest(unittest.TestCase): @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.assertIn(5, l) self.assertNotIn([1, 2, 3, 4, 5], l) self.assertNotIn(0, l) @@ -820,66 +820,66 @@ class ListTest(unittest.TestCase): @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): @@ -892,13 +892,13 @@ class ListTest(unittest.TestCase): 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) @@ -913,10 +913,10 @@ class ListTest(unittest.TestCase): 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): @@ -932,20 +932,20 @@ class ListTest(unittest.TestCase): 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 = [file] * 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]) @@ -961,9 +961,9 @@ class ListTest(unittest.TestCase): def test_index(self, size): l = [1L, 2L, 3L, 4L, 5L] * 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, 6L) @@ -973,80 +973,80 @@ class ListTest(unittest.TestCase): 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 = [u"a", u"b", u"c", u"d", u"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, u"e") - self.assertEquals(l[-2:], [u"c", u"d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, u"e") + self.assertEqual(l[-2:], [u"c", u"d"]) item = l.pop(0) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, u"a") - self.assertEquals(l[:2], [u"b", u"c"]) + self.assertEqual(len(l), size) + self.assertEqual(item, u"a") + self.assertEqual(l[:2], [u"b", u"c"]) item = l.pop(size - 2) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, u"c") - self.assertEquals(l[-2:], [u"b", u"d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, u"c") + self.assertEqual(l[-2:], [u"b", u"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) class BufferTest(unittest.TestCase): @@ -1060,9 +1060,9 @@ class BufferTest(unittest.TestCase): else: count = 0 for c in b: - self.assertEquals(c, 'A') + self.assertEqual(c, 'A') count += 1 - self.assertEquals(count, size*4) + self.assertEqual(count, size*4) def test_main(): test_support.run_unittest(StrTest, TupleTest, ListTest, BufferTest) diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 69b6ae4..d8fb2d5 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -651,15 +651,15 @@ class BuiltinTest(unittest.TestCase): 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(long): def __hash__(self): return self - self.assertEquals(hash(Z(42)), hash(42L)) + self.assertEqual(hash(Z(42)), hash(42L)) def test_hex(self): self.assertEqual(hex(16), '0x10') @@ -930,7 +930,7 @@ class BuiltinTest(unittest.TestCase): 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): @@ -939,7 +939,7 @@ class BuiltinTest(unittest.TestCase): raise StopIteration it = iter(Iter()) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) self.assertRaises(StopIteration, next, it) def gen(): @@ -947,9 +947,9 @@ class BuiltinTest(unittest.TestCase): 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), '0144') diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index d0f5662..6b5ef36 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -255,11 +255,11 @@ class BaseBytesTest(unittest.TestCase): def test_fromhex(self): self.assertRaises(TypeError, self.type2test.fromhex) self.assertRaises(TypeError, self.type2test.fromhex, 1) - self.assertEquals(self.type2test.fromhex(u''), self.type2test()) + self.assertEqual(self.type2test.fromhex(u''), self.type2test()) b = bytearray([0x1a, 0x2b, 0x30]) - self.assertEquals(self.type2test.fromhex(u'1a2B30'), b) - self.assertEquals(self.type2test.fromhex(u' 1A 2B 30 '), b) - self.assertEquals(self.type2test.fromhex(u'0000'), b'\0\0') + self.assertEqual(self.type2test.fromhex(u'1a2B30'), b) + self.assertEqual(self.type2test.fromhex(u' 1A 2B 30 '), b) + self.assertEqual(self.type2test.fromhex(u'0000'), b'\0\0') self.assertRaises(ValueError, self.type2test.fromhex, u'a') self.assertRaises(ValueError, self.type2test.fromhex, u'rt') self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd') @@ -587,11 +587,11 @@ class ByteArrayTest(BaseBytesTest): 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 @@ -771,25 +771,25 @@ class ByteArrayTest(BaseBytesTest): 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 20c10dc..d44a415 100644 --- a/Lib/test/test_cfgparser.py +++ b/Lib/test/test_cfgparser.py @@ -572,14 +572,14 @@ class SortedTestCase(RawConfigParserTestCase): "k=v\n") output = StringIO.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(): diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py index 554bf06..e282a51 100644 --- a/Lib/test/test_cgi.py +++ b/Lib/test/test_cgi.py @@ -251,7 +251,7 @@ Content-Disposition: form-data; name="submit" -----------------------------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.\n'}, @@ -259,7 +259,7 @@ Content-Disposition: form-data; name="submit" 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 2866984..d984059 100644 --- a/Lib/test/test_charmapcodec.py +++ b/Lib/test/test_charmapcodec.py @@ -27,24 +27,24 @@ codecname = 'testcodec' class CharmapCodecTest(unittest.TestCase): def test_constructorx(self): - self.assertEquals(unicode('abc', codecname), u'abc') - self.assertEquals(unicode('xdef', codecname), u'abcdef') - self.assertEquals(unicode('defx', codecname), u'defabc') - self.assertEquals(unicode('dxf', codecname), u'dabcf') - self.assertEquals(unicode('dxfx', codecname), u'dabcfabc') + self.assertEqual(unicode('abc', codecname), u'abc') + self.assertEqual(unicode('xdef', codecname), u'abcdef') + self.assertEqual(unicode('defx', codecname), u'defabc') + self.assertEqual(unicode('dxf', codecname), u'dabcf') + self.assertEqual(unicode('dxfx', codecname), u'dabcfabc') def test_encodex(self): - self.assertEquals(u'abc'.encode(codecname), 'abc') - self.assertEquals(u'xdef'.encode(codecname), 'abcdef') - self.assertEquals(u'defx'.encode(codecname), 'defabc') - self.assertEquals(u'dxf'.encode(codecname), 'dabcf') - self.assertEquals(u'dxfx'.encode(codecname), 'dabcfabc') + self.assertEqual(u'abc'.encode(codecname), 'abc') + self.assertEqual(u'xdef'.encode(codecname), 'abcdef') + self.assertEqual(u'defx'.encode(codecname), 'defabc') + self.assertEqual(u'dxf'.encode(codecname), 'dabcf') + self.assertEqual(u'dxfx'.encode(codecname), 'dabcfabc') def test_constructory(self): - self.assertEquals(unicode('ydef', codecname), u'def') - self.assertEquals(unicode('defy', codecname), u'def') - self.assertEquals(unicode('dyf', codecname), u'df') - self.assertEquals(unicode('dyfy', codecname), u'df') + self.assertEqual(unicode('ydef', codecname), u'def') + self.assertEqual(unicode('defy', codecname), u'def') + self.assertEqual(unicode('dyf', codecname), u'df') + self.assertEqual(unicode('dyfy', codecname), u'df') def test_maptoundefined(self): self.assertRaises(UnicodeError, unicode, 'abc\001', codecname) diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py index e7b7752..0f25101 100644 --- a/Lib/test/test_class.py +++ b/Lib/test/test_class.py @@ -475,7 +475,7 @@ class ClassTests(unittest.TestCase): 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 @@ -507,14 +507,14 @@ class ClassTests(unittest.TestCase): callLst[:] = [] as_int = int(mixIntAndLong) - self.assertEquals(type(as_int), long) - self.assertEquals(as_int, 42L) + self.assertEqual(type(as_int), long) + self.assertEqual(as_int, 42L) self.assertCallStack([('__int__', (mixIntAndLong,))]) callLst[:] = [] as_long = long(mixIntAndLong) - self.assertEquals(type(as_long), long) - self.assertEquals(as_long, 64) + self.assertEqual(type(as_long), long) + self.assertEqual(as_long, 64) self.assertCallStack([('__long__', (mixIntAndLong,))]) def testHashStuff(self): @@ -599,17 +599,17 @@ class ClassTests(unittest.TestCase): 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.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.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.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.im_func)^(-1)) diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py index e83a919..97adf59 100644 --- a/Lib/test/test_code.py +++ b/Lib/test/test_code.py @@ -106,9 +106,9 @@ class CodeTest(unittest.TestCase): def test_newempty(self): co = _testcapi.code_newempty("filename", "funcname", 15) - self.assertEquals(co.co_filename, "filename") - self.assertEquals(co.co_name, "funcname") - self.assertEquals(co.co_firstlineno, 15) + self.assertEqual(co.co_filename, "filename") + self.assertEqual(co.co_name, "funcname") + self.assertEqual(co.co_firstlineno, 15) class CodeWeakRefTest(unittest.TestCase): diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py index 635a15f..4825f43 100644 --- a/Lib/test/test_codeccallbacks.py +++ b/Lib/test/test_codeccallbacks.py @@ -186,7 +186,7 @@ class CodecCallbackTest(unittest.TestCase): charmap = dict([ (ord(c), 2*c.upper()) for c in "abcdefgh"]) sin = u"abc" sout = "AABBCC" - self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout) sin = u"abcA" self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap) @@ -194,7 +194,7 @@ class CodecCallbackTest(unittest.TestCase): charmap[ord("?")] = "XYZ" sin = u"abcDEF" sout = "AABBCCXYZXYZXYZ" - self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout) charmap[ord("?")] = u"XYZ" self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap) @@ -327,7 +327,7 @@ class CodecCallbackTest(unittest.TestCase): # 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,15 +437,15 @@ class CodecCallbackTest(unittest.TestCase): UnicodeError("ouch") ) # If the correct exception is passed in, "ignore" returns an empty replacement - self.assertEquals( + self.assertEqual( codecs.ignore_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), (u"", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors(UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch")), (u"", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors(UnicodeTranslateError(u"\u3042", 0, 1, "ouch")), (u"", 1) ) @@ -474,15 +474,15 @@ class CodecCallbackTest(unittest.TestCase): BadObjectUnicodeDecodeError() ) # With the correct exception, "replace" returns an "?" or u"\ufffd" replacement - self.assertEquals( + self.assertEqual( codecs.replace_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), (u"?", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors(UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch")), (u"\ufffd", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors(UnicodeTranslateError(u"\u3042", 0, 1, "ouch")), (u"\ufffd", 1) ) @@ -514,7 +514,7 @@ class CodecCallbackTest(unittest.TestCase): # Use the correct exception cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) s = "".join(unichr(c) for c in cs) - self.assertEquals( + self.assertEqual( codecs.xmlcharrefreplace_errors( UnicodeEncodeError("ascii", s, 0, len(s), "ouch") ), @@ -546,32 +546,32 @@ class CodecCallbackTest(unittest.TestCase): UnicodeTranslateError(u"\u3042", 0, 1, "ouch") ) # Use the correct exception - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), (u"\\u3042", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\x00", 0, 1, "ouch")), (u"\\x00", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\xff", 0, 1, "ouch")), (u"\\xff", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\u0100", 0, 1, "ouch")), (u"\\u0100", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\uffff", 0, 1, "ouch")), (u"\\uffff", 1) ) if sys.maxunicode>0xffff: - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\U00010000", 0, 1, "ouch")), (u"\\U00010000", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\U0010ffff", 0, 1, "ouch")), (u"\\U0010ffff", 1) ) @@ -603,14 +603,14 @@ class CodecCallbackTest(unittest.TestCase): ) 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") ) @@ -686,11 +686,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?>0") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"<?>0") # Valid negative position handler.pos = -2 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?><?>") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"<?><?>") # Negative position out of bounds handler.pos = -3 @@ -698,11 +698,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?>0") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"<?>0") # Largest valid positive position (one beyond end of input) handler.pos = 2 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"<?>") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"<?>") # Invalid positive position handler.pos = 3 @@ -710,7 +710,7 @@ class CodecCallbackTest(unittest.TestCase): # Restart at the "0" handler.pos = 6 - self.assertEquals("\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), u"<?>0") + self.assertEqual("\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), u"<?>0") class D(dict): def __getitem__(self, key): @@ -740,11 +740,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?>0") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "<?>0") # Valid negative position handler.pos = -2 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?><?>") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "<?><?>") # Negative position out of bounds handler.pos = -3 @@ -752,11 +752,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?>0") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "<?>0") # Largest valid positive position (one beyond end of input handler.pos = 2 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "<?>") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "<?>") # Invalid positive position handler.pos = 3 diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py index 4c020c3..7cd7141 100644 --- a/Lib/test/test_codecs.py +++ b/Lib/test/test_codecs.py @@ -267,7 +267,7 @@ class UTF32Test(ReadTest): # try to read it back s = StringIO.StringIO(d) f = reader(s) - self.assertEquals(f.read(), u"spamspam") + self.assertEqual(f.read(), u"spamspam") def test_badbom(self): s = StringIO.StringIO(4*"\xff") @@ -425,7 +425,7 @@ class UTF16Test(ReadTest): # try to read it back s = StringIO.StringIO(d) f = reader(s) - self.assertEquals(f.read(), u"spamspam") + self.assertEqual(f.read(), u"spamspam") def test_badbom(self): s = StringIO.StringIO("\xff\xff") @@ -673,7 +673,7 @@ class UTF8SigTest(ReadTest): 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): @@ -800,11 +800,11 @@ class PunycodeTest(unittest.TestCase): # code produces only lower case. Converting just puny to # lower is also insufficient, since some of the input characters # are upper case. - self.assertEquals(uni.encode("punycode").lower(), puny.lower()) + self.assertEqual(uni.encode("punycode").lower(), puny.lower()) def test_decode(self): for uni, puny in punycode_testcases: - self.assertEquals(uni, puny.decode("punycode")) + self.assertEqual(uni, puny.decode("punycode")) class UnicodeInternalTest(unittest.TestCase): def test_bug1251300(self): @@ -826,7 +826,7 @@ class UnicodeInternalTest(unittest.TestCase): for internal, uni in ok: if sys.byteorder == "little": internal = "".join(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 = "".join(reversed(internal)) @@ -838,10 +838,10 @@ class UnicodeInternalTest(unittest.TestCase): try: "\x00\x00\x00\x00\x00\x11\x11\x00".decode("unicode_internal") except UnicodeDecodeError, ex: - self.assertEquals("unicode_internal", ex.encoding) - self.assertEquals("\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("\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) + self.assertEqual(4, ex.start) + self.assertEqual(8, ex.end) else: self.fail() @@ -852,16 +852,16 @@ class UnicodeInternalTest(unittest.TestCase): ab = u"ab".encode("unicode_internal") ignored = decoder("%s\x22\x22\x22\x22%s" % (ab[:4], ab[4:]), "UnicodeInternalTest") - self.assertEquals((u"ab", 12), ignored) + self.assertEqual((u"ab", 12), ignored) def test_encode_length(self): # Issue 3739 encoder = codecs.getencoder("unicode_internal") - self.assertEquals(encoder(u"a")[1], 1) - self.assertEquals(encoder(u"\xe9\u0142")[1], 2) + self.assertEqual(encoder(u"a")[1], 1) + self.assertEqual(encoder(u"\xe9\u0142")[1], 2) encoder = codecs.getencoder("string-escape") - self.assertEquals(encoder(r'\x00')[1], 4) + self.assertEqual(encoder(r'\x00')[1], 4) # From http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html nameprep_tests = [ @@ -1032,102 +1032,102 @@ class NameprepTest(unittest.TestCase): else: prepped = unicode(prepped, "utf-8") try: - self.assertEquals(nameprep(orig), prepped) + self.assertEqual(nameprep(orig), prepped) except Exception,e: raise test_support.TestFailed("Test 3.%d: %s" % (pos+1, str(e))) class IDNACodecTest(unittest.TestCase): def test_builtin_decode(self): - self.assertEquals(unicode("python.org", "idna"), u"python.org") - self.assertEquals(unicode("python.org.", "idna"), u"python.org.") - self.assertEquals(unicode("xn--pythn-mua.org", "idna"), u"pyth\xf6n.org") - self.assertEquals(unicode("xn--pythn-mua.org.", "idna"), u"pyth\xf6n.org.") + self.assertEqual(unicode("python.org", "idna"), u"python.org") + self.assertEqual(unicode("python.org.", "idna"), u"python.org.") + self.assertEqual(unicode("xn--pythn-mua.org", "idna"), u"pyth\xf6n.org") + self.assertEqual(unicode("xn--pythn-mua.org.", "idna"), u"pyth\xf6n.org.") def test_builtin_encode(self): - self.assertEquals(u"python.org".encode("idna"), "python.org") - self.assertEquals("python.org.".encode("idna"), "python.org.") - self.assertEquals(u"pyth\xf6n.org".encode("idna"), "xn--pythn-mua.org") - self.assertEquals(u"pyth\xf6n.org.".encode("idna"), "xn--pythn-mua.org.") + self.assertEqual(u"python.org".encode("idna"), "python.org") + self.assertEqual("python.org.".encode("idna"), "python.org.") + self.assertEqual(u"pyth\xf6n.org".encode("idna"), "xn--pythn-mua.org") + self.assertEqual(u"pyth\xf6n.org.".encode("idna"), "xn--pythn-mua.org.") def test_stream(self): import StringIO r = codecs.getreader("idna")(StringIO.StringIO("abc")) r.read(3) - self.assertEquals(r.read(), u"") + self.assertEqual(r.read(), u"") def test_incremental_decode(self): - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("python.org", "idna")), u"python.org" ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("python.org.", "idna")), u"python.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("xn--pythn-mua.org.", "idna")), u"pyth\xf6n.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("xn--pythn-mua.org.", "idna")), u"pyth\xf6n.org." ) decoder = codecs.getincrementaldecoder("idna")() - self.assertEquals(decoder.decode("xn--xam", ), u"") - self.assertEquals(decoder.decode("ple-9ta.o", ), u"\xe4xample.") - self.assertEquals(decoder.decode(u"rg"), u"") - self.assertEquals(decoder.decode(u"", True), u"org") + self.assertEqual(decoder.decode("xn--xam", ), u"") + self.assertEqual(decoder.decode("ple-9ta.o", ), u"\xe4xample.") + self.assertEqual(decoder.decode(u"rg"), u"") + self.assertEqual(decoder.decode(u"", True), u"org") decoder.reset() - self.assertEquals(decoder.decode("xn--xam", ), u"") - self.assertEquals(decoder.decode("ple-9ta.o", ), u"\xe4xample.") - self.assertEquals(decoder.decode("rg."), u"org.") - self.assertEquals(decoder.decode("", True), u"") + self.assertEqual(decoder.decode("xn--xam", ), u"") + self.assertEqual(decoder.decode("ple-9ta.o", ), u"\xe4xample.") + self.assertEqual(decoder.decode("rg."), u"org.") + self.assertEqual(decoder.decode("", True), u"") def test_incremental_encode(self): - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"python.org", "idna")), "python.org" ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"python.org.", "idna")), "python.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"pyth\xf6n.org.", "idna")), "xn--pythn-mua.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"pyth\xf6n.org.", "idna")), "xn--pythn-mua.org." ) encoder = codecs.getincrementalencoder("idna")() - self.assertEquals(encoder.encode(u"\xe4x"), "") - self.assertEquals(encoder.encode(u"ample.org"), "xn--xample-9ta.") - self.assertEquals(encoder.encode(u"", True), "org") + self.assertEqual(encoder.encode(u"\xe4x"), "") + self.assertEqual(encoder.encode(u"ample.org"), "xn--xample-9ta.") + self.assertEqual(encoder.encode(u"", True), "org") encoder.reset() - self.assertEquals(encoder.encode(u"\xe4x"), "") - self.assertEquals(encoder.encode(u"ample.org."), "xn--xample-9ta.org.") - self.assertEquals(encoder.encode(u"", True), "") + self.assertEqual(encoder.encode(u"\xe4x"), "") + self.assertEqual(encoder.encode(u"ample.org."), "xn--xample-9ta.org.") + self.assertEqual(encoder.encode(u"", True), "") class CodecsModuleTest(unittest.TestCase): def test_decode(self): - self.assertEquals(codecs.decode('\xe4\xf6\xfc', 'latin-1'), + self.assertEqual(codecs.decode('\xe4\xf6\xfc', 'latin-1'), u'\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.decode) - self.assertEquals(codecs.decode('abc'), u'abc') + self.assertEqual(codecs.decode('abc'), u'abc') self.assertRaises(UnicodeDecodeError, codecs.decode, '\xff', 'ascii') def test_encode(self): - self.assertEquals(codecs.encode(u'\xe4\xf6\xfc', 'latin-1'), + self.assertEqual(codecs.encode(u'\xe4\xf6\xfc', 'latin-1'), '\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.encode) self.assertRaises(LookupError, codecs.encode, "foo", "__spam__") - self.assertEquals(codecs.encode(u'abc'), 'abc') + self.assertEqual(codecs.encode(u'abc'), 'abc') self.assertRaises(UnicodeEncodeError, codecs.encode, u'\xffff', 'ascii') def test_register(self): @@ -1163,19 +1163,19 @@ class StreamReaderTest(unittest.TestCase): def test_readlines(self): f = self.reader(self.stream) - self.assertEquals(f.readlines(), [u'\ud55c\n', u'\uae00']) + self.assertEqual(f.readlines(), [u'\ud55c\n', u'\uae00']) class EncodedFileTest(unittest.TestCase): def test_basic(self): f = StringIO.StringIO('\xed\x95\x9c\n\xea\xb8\x80') ef = codecs.EncodedFile(f, 'utf-16-le', 'utf-8') - self.assertEquals(ef.read(), '\\\xd5\n\x00\x00\xae') + self.assertEqual(ef.read(), '\\\xd5\n\x00\x00\xae') f = StringIO.StringIO() ef = codecs.EncodedFile(f, 'utf-8', 'latin1') ef.write('\xc3\xbc') - self.assertEquals(f.getvalue(), '\xfc') + self.assertEqual(f.getvalue(), '\xfc') class Str2StrTest(unittest.TestCase): @@ -1478,33 +1478,33 @@ class BasicStrTest(unittest.TestCase): class CharmapTest(unittest.TestCase): def test_decode_with_string_map(self): - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "strict", u"abc"), (u"abc", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "replace", u"ab"), (u"ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "replace", u"ab\ufffe"), (u"ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "ignore", u"ab"), (u"ab", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "ignore", u"ab\ufffe"), (u"ab", 3) ) allbytes = "".join(chr(i) for i in xrange(256)) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(allbytes, "ignore", u""), (u"", len(allbytes)) ) @@ -1513,14 +1513,14 @@ class WithStmtTest(unittest.TestCase): def test_encodedfile(self): f = StringIO.StringIO("\xc3\xbc") with codecs.EncodedFile(f, "latin-1", "utf-8") as ef: - self.assertEquals(ef.read(), "\xfc") + self.assertEqual(ef.read(), "\xfc") def test_streamreaderwriter(self): f = StringIO.StringIO("\xc3\xbc") info = codecs.lookup("utf-8") with codecs.StreamReaderWriter(f, info.streamreader, info.streamwriter, 'strict') as srw: - self.assertEquals(srw.read(), u"\xfc") + self.assertEqual(srw.read(), u"\xfc") class BomTest(unittest.TestCase): @@ -1538,27 +1538,27 @@ class BomTest(unittest.TestCase): 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(test_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(test_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 @@ -1567,7 +1567,7 @@ class BomTest(unittest.TestCase): 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 @@ -1576,7 +1576,7 @@ class BomTest(unittest.TestCase): 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 da3b83f..99fe6f9 100644 --- a/Lib/test/test_codeop.py +++ b/Lib/test/test_codeop.py @@ -37,14 +37,14 @@ class CodeopTests(unittest.TestCase): 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 @@ class CodeopTests(unittest.TestCase): # 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 @@ class CodeopTests(unittest.TestCase): 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_main(): diff --git a/Lib/test/test_coercion.py b/Lib/test/test_coercion.py index 0ca00a6..2b55c41 100644 --- a/Lib/test/test_coercion.py +++ b/Lib/test/test_coercion.py @@ -266,9 +266,9 @@ class CoercionTest(unittest.TestCase): self.assertRaises(TypeError, eval, 'a %s b' % op, {'a': a, 'b': b}) else: - self.assertEquals(format_result(res), - format_result(eval('a %s b' % op)), - '%s %s %s == %s failed' % (a, op, b, res)) + self.assertEqual(format_result(res), + format_result(eval('a %s b' % op)), + '%s %s %s == %s failed' % (a, op, b, res)) try: z = copy.copy(a) except copy.Error: @@ -282,7 +282,7 @@ class CoercionTest(unittest.TestCase): self.fail("TypeError not raised") else: exec('z %s= b' % op) - self.assertEquals(ires, z) + self.assertEqual(ires, z) def test_prefix_binops(self): for ia, a in enumerate(candidates): @@ -293,9 +293,9 @@ class CoercionTest(unittest.TestCase): self.assertRaises(TypeError, eval, '%s(a, b)' % op, {'a': a, 'b': b}) else: - self.assertEquals(format_result(res), - format_result(eval('%s(a, b)' % op)), - '%s(%s, %s) == %s failed' % (op, a, b, res)) + self.assertEqual(format_result(res), + format_result(eval('%s(a, b)' % op)), + '%s(%s, %s) == %s failed' % (op, a, b, res)) def test_cmptypes(self): # Built-in tp_compare slots expect their arguments to have the @@ -303,21 +303,21 @@ class CoercionTest(unittest.TestCase): # SF #980352 evil_coercer = CoerceTo(42) # Make sure these don't crash any more - self.assertNotEquals(cmp(u'fish', evil_coercer), 0) - self.assertNotEquals(cmp(slice(1), evil_coercer), 0) + self.assertNotEqual(cmp(u'fish', evil_coercer), 0) + self.assertNotEqual(cmp(slice(1), evil_coercer), 0) # ...but that this still works class WackyComparer(object): def __cmp__(slf, other): self.assertTrue(other == 42, 'expected evil_coercer, got %r' % other) return 0 __hash__ = None # Invalid cmp makes this unhashable - self.assertEquals(cmp(WackyComparer(), evil_coercer), 0) + self.assertEqual(cmp(WackyComparer(), evil_coercer), 0) # ...and classic classes too, since that code path is a little different class ClassicWackyComparer: def __cmp__(slf, other): self.assertTrue(other == 42, 'expected evil_coercer, got %r' % other) return 0 - self.assertEquals(cmp(ClassicWackyComparer(), evil_coercer), 0) + self.assertEqual(cmp(ClassicWackyComparer(), evil_coercer), 0) def test_infinite_rec_classic_classes(self): # if __coerce__() returns its arguments reversed it causes an infinite diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index 3f24008..94305ab 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -674,9 +674,9 @@ class TestCounter(unittest.TestCase): ]): 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 @@ -897,10 +897,10 @@ class TestOrderedDict(unittest.TestCase): 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_commands.py b/Lib/test/test_commands.py index 2d10dea..70cfb58 100644 --- a/Lib/test/test_commands.py +++ b/Lib/test/test_commands.py @@ -24,8 +24,8 @@ if os.name != 'posix': class CommandTests(unittest.TestCase): def test_getoutput(self): - self.assertEquals(commands.getoutput('echo xyzzy'), 'xyzzy') - self.assertEquals(commands.getstatusoutput('echo xyzzy'), (0, 'xyzzy')) + self.assertEqual(commands.getoutput('echo xyzzy'), 'xyzzy') + self.assertEqual(commands.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 @@ -36,7 +36,7 @@ class CommandTests(unittest.TestCase): name = os.path.join(dir, "foo") status, output = commands.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_compiler.py b/Lib/test/test_compiler.py index e36a355..332e0bb 100644 --- a/Lib/test/test_compiler.py +++ b/Lib/test/test_compiler.py @@ -81,8 +81,8 @@ class CompilerTest(unittest.TestCase): "<string>", "exec") dct = {} exec c in dct - self.assertEquals(dct.get('e'), 1) - self.assertEquals(dct.get('f'), 1) + self.assertEqual(dct.get('e'), 1) + self.assertEqual(dct.get('f'), 1) def testDefaultArgs(self): self.assertRaises(SyntaxError, compiler.parse, "def foo(a=1, b): pass") @@ -93,7 +93,7 @@ class CompilerTest(unittest.TestCase): c = compiler.compile('def f():\n "doc"', '<string>', 'exec') g = {} exec c in g - self.assertEquals(g['f'].__doc__, "doc") + self.assertEqual(g['f'].__doc__, "doc") def testLineNo(self): # Test that all nodes except Module have a correct lineno attribute. @@ -120,8 +120,8 @@ class CompilerTest(unittest.TestCase): self.check_lineno(child) def testFlatten(self): - self.assertEquals(flatten([1, [2]]), [1, 2]) - self.assertEquals(flatten((1, (2,))), [1, 2]) + self.assertEqual(flatten([1, [2]]), [1, 2]) + self.assertEqual(flatten((1, (2,))), [1, 2]) def testNestedScope(self): c = compiler.compile('def g():\n' @@ -133,44 +133,44 @@ class CompilerTest(unittest.TestCase): 'exec') dct = {} exec c in dct - self.assertEquals(dct.get('result'), 3) + self.assertEqual(dct.get('result'), 3) def testGenExp(self): c = compiler.compile('list((i,j) for i in range(3) if i < 3' ' for j in range(4) if j > 2)', '<string>', 'eval') - self.assertEquals(eval(c), [(0, 3), (1, 3), (2, 3)]) + self.assertEqual(eval(c), [(0, 3), (1, 3), (2, 3)]) def testSetLiteral(self): c = compiler.compile('{1, 2, 3}', '<string>', 'eval') - self.assertEquals(eval(c), {1,2,3}) + self.assertEqual(eval(c), {1,2,3}) c = compiler.compile('{1, 2, 3,}', '<string>', 'eval') - self.assertEquals(eval(c), {1,2,3}) + self.assertEqual(eval(c), {1,2,3}) def testDictLiteral(self): c = compiler.compile('{1:2, 2:3, 3:4}', '<string>', 'eval') - self.assertEquals(eval(c), {1:2, 2:3, 3:4}) + self.assertEqual(eval(c), {1:2, 2:3, 3:4}) c = compiler.compile('{1:2, 2:3, 3:4,}', '<string>', 'eval') - self.assertEquals(eval(c), {1:2, 2:3, 3:4}) + self.assertEqual(eval(c), {1:2, 2:3, 3:4}) def testSetComp(self): c = compiler.compile('{x for x in range(1, 4)}', '<string>', 'eval') - self.assertEquals(eval(c), {1, 2, 3}) + self.assertEqual(eval(c), {1, 2, 3}) c = compiler.compile('{x * y for x in range(3) if x != 0' ' for y in range(4) if y != 0}', '<string>', 'eval') - self.assertEquals(eval(c), {1, 2, 3, 4, 6}) + self.assertEqual(eval(c), {1, 2, 3, 4, 6}) def testDictComp(self): c = compiler.compile('{x:x+1 for x in range(1, 4)}', '<string>', 'eval') - self.assertEquals(eval(c), {1:2, 2:3, 3:4}) + self.assertEqual(eval(c), {1:2, 2:3, 3:4}) c = compiler.compile('{(x, y) : y for x in range(2) if x != 0' ' for y in range(3) if y != 0}', '<string>', 'eval') - self.assertEquals(eval(c), {(1, 2): 2, (1, 1): 1}) + self.assertEqual(eval(c), {(1, 2): 2, (1, 1): 1}) def testWith(self): # SF bug 1638243 @@ -183,7 +183,7 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'TrivialContext': TrivialContext} exec c in dct - self.assertEquals(dct.get('result'), 1) + self.assertEqual(dct.get('result'), 1) def testWithAss(self): c = compiler.compile('from __future__ import with_statement\n' @@ -195,7 +195,7 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'TrivialContext': TrivialContext} exec c in dct - self.assertEquals(dct.get('result'), 1) + self.assertEqual(dct.get('result'), 1) def testWithMult(self): events = [] @@ -215,8 +215,8 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'Ctx': Ctx} exec c in dct - self.assertEquals(dct.get('result'), 1) - self.assertEquals(events, [1, 2]) + self.assertEqual(dct.get('result'), 1) + self.assertEqual(events, [1, 2]) def testGlobal(self): code = compiler.compile('global x\nx=1', '<string>', 'exec') @@ -224,7 +224,7 @@ class CompilerTest(unittest.TestCase): d2 = {} exec code in d1, d2 # x should be in the globals dict - self.assertEquals(d1.get('x'), 1) + self.assertEqual(d1.get('x'), 1) def testPrintFunction(self): c = compiler.compile('from __future__ import print_function\n' @@ -234,14 +234,14 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'output': StringIO()} exec c in dct - self.assertEquals(dct['output'].getvalue(), 'a**b++') + self.assertEqual(dct['output'].getvalue(), 'a**b++') def _testErrEnc(self, src, text, offset): try: compile(src, "", "exec") except SyntaxError, e: - self.assertEquals(e.offset, offset) - self.assertEquals(e.text, text) + self.assertEqual(e.offset, offset) + self.assertEqual(e.text, text) def testSourceCodeEncodingsError(self): # Test SyntaxError with encoding definition diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py index a459f84..59e8677 100644 --- a/Lib/test/test_complex.py +++ b/Lib/test/test_complex.py @@ -501,8 +501,8 @@ class ComplexTest(unittest.TestCase): 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_cookielib.py b/Lib/test/test_cookielib.py index 62a275b..dd0ad32 100644 --- a/Lib/test/test_cookielib.py +++ b/Lib/test/test_cookielib.py @@ -18,10 +18,10 @@ class DateTimeTests(TestCase): 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 @@ class DateTimeTests(TestCase): 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): from cookielib import http2time, time2isoz @@ -71,8 +71,8 @@ class DateTimeTests(TestCase): 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) @@ -114,7 +114,7 @@ class HeaderTests(TestCase): '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_version(self): from cookielib import parse_ns_headers @@ -125,7 +125,7 @@ class HeaderTests(TestCase): 'foo=bar; version="1"', 'foo=bar; Version="1"', ]: - 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 @@ -135,15 +135,15 @@ class HeaderTests(TestCase): # 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): from cookielib import join_header_words 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): from cookielib import split_header_words @@ -175,7 +175,7 @@ class HeaderTests(TestCase): f = StringIO.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' @@ -209,7 +209,7 @@ Got: '%s' 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' @@ -380,11 +380,11 @@ class CookieTests(TestCase): 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) @@ -395,13 +395,13 @@ class CookieTests(TestCase): 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, @@ -449,18 +449,18 @@ class CookieTests(TestCase): '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"] @@ -494,13 +494,13 @@ class CookieTests(TestCase): 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 @@ -509,19 +509,19 @@ class CookieTests(TestCase): 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.assertIn('spam="bar"', h) # XXX RFC 2965 expiry rules (some apply to V0 too) @@ -576,7 +576,7 @@ class CookieTests(TestCase): # 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): from cookielib import escape_path @@ -600,7 +600,7 @@ class CookieTests(TestCase): (u"/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): from urllib2 import Request @@ -608,25 +608,25 @@ class CookieTests(TestCase): # with parameters req = Request("http://www.example.com/rheum/rhaponticum;" "foo=bar;sing=song?apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), - "/rheum/rhaponticum;foo=bar;sing=song") + self.assertEqual(request_path(req), + "/rheum/rhaponticum;foo=bar;sing=song") # without parameters req = 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 = Request("http://www.example.com") - self.assertEquals(request_path(req), "/") + self.assertEqual(request_path(req), "/") def test_request_port(self): from urllib2 import Request from cookielib import request_port, DEFAULT_HTTP_PORT req = 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 = 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): from urllib2 import Request @@ -636,20 +636,20 @@ class CookieTests(TestCase): 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 = 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") # not actually sure this one is valid Request object, so maybe should # remove test for no host in url in request_host function? req = Request("/resource.html", headers={"Host": "www.acme.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 = 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): from cookielib import is_HDN @@ -664,14 +664,14 @@ class CookieTests(TestCase): def test_reach(self): from cookielib import reach - 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): from cookielib import domain_match, user_domain_match @@ -719,7 +719,7 @@ class CookieTests(TestCase): 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 @@ -731,11 +731,11 @@ class CookieTests(TestCase): 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 @@ -747,17 +747,17 @@ class CookieTests(TestCase): # 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 @@ -766,17 +766,17 @@ class CookieTests(TestCase): # 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 @@ -784,8 +784,8 @@ class CookieTests(TestCase): # 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): from cookielib import CookieJar, DefaultCookiePolicy @@ -795,43 +795,43 @@ class CookieTests(TestCase): # 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): from cookielib import CookieJar, DefaultCookiePolicy @@ -845,24 +845,24 @@ class CookieTests(TestCase): 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 = 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 = 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 = 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")) @@ -879,17 +879,17 @@ class CookieTests(TestCase): req = 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 = 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 = Request("http://www.roadrunner.net/") c.add_cookie_header(req) self.assertTrue((req.has_header("Cookie") and @@ -898,14 +898,14 @@ class CookieTests(TestCase): 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 = 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")) @@ -940,7 +940,7 @@ class CookieTests(TestCase): 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. @@ -950,7 +950,7 @@ class CookieTests(TestCase): c = CookieJar(DefaultCookiePolicy(rfc2965=True)) interact_2965(c, url, "foo=bar; Version=1") req = Request(url) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.add_cookie_header(req) self.assertTrue(req.has_header("Cookie")) @@ -1070,33 +1070,33 @@ class CookieTests(TestCase): i = 0 for c in cs: self.assertIsInstance(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): from cookielib import parse_ns_headers # 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): @@ -1122,7 +1122,7 @@ class CookieTests(TestCase): ]: 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"] @@ -1267,7 +1267,7 @@ class LWPCookieTests(TestCase): req = Request("http://www.acme.com/") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), + self.assertEqual(req.get_header("Cookie"), "PART_NUMBER=ROCKET_LAUNCHER_0001") headers.append( @@ -1471,40 +1471,40 @@ class LWPCookieTests(TestCase): # 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( @@ -1512,13 +1512,13 @@ class LWPCookieTests(TestCase): 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 @@ -1529,7 +1529,7 @@ class LWPCookieTests(TestCase): # 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 @@ -1544,7 +1544,7 @@ class LWPCookieTests(TestCase): 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. @@ -1604,11 +1604,11 @@ class LWPCookieTests(TestCase): 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.assertIn("name='foo1', value='bar'", 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.assertIn("name='foo1', value='bar'", repr(new_c)) def test_netscape_misc(self): @@ -1661,12 +1661,12 @@ class LWPCookieTests(TestCase): 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.assertIn("foo1=bar", cookie) cookie = interact_netscape(c, "http://example/") self.assertIn("foo2=bar", cookie) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) def test_empty_path(self): from cookielib import CookieJar, DefaultCookiePolicy @@ -1690,17 +1690,17 @@ class LWPCookieTests(TestCase): req = 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 = 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): from cookielib import CookieJar diff --git a/Lib/test/test_copy_reg.py b/Lib/test/test_copy_reg.py index 012c802..8cdb8b7 100644 --- a/Lib/test/test_copy_reg.py +++ b/Lib/test/test_copy_reg.py @@ -40,7 +40,7 @@ class CopyRegTestCase(unittest.TestCase): 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 @@ class CopyRegTestCase(unittest.TestCase): mod, func, code) def test_slotnames(self): - self.assertEquals(copy_reg._slotnames(WithoutSlots), []) - self.assertEquals(copy_reg._slotnames(WithWeakref), []) + self.assertEqual(copy_reg._slotnames(WithoutSlots), []) + self.assertEqual(copy_reg._slotnames(WithWeakref), []) expected = ['_WithPrivate__spam'] - self.assertEquals(copy_reg._slotnames(WithPrivate), expected) - self.assertEquals(copy_reg._slotnames(WithSingleString), ['spam']) + self.assertEqual(copy_reg._slotnames(WithPrivate), expected) + self.assertEqual(copy_reg._slotnames(WithSingleString), ['spam']) expected = ['eggs', 'spam'] expected.sort() result = copy_reg._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 905f7ef..15188db 100644 --- a/Lib/test/test_datetime.py +++ b/Lib/test/test_datetime.py @@ -1491,8 +1491,8 @@ class TestDateTime(TestDate): 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, @@ -1520,7 +1520,7 @@ class TestDateTime(TestDate): @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_deque.py b/Lib/test/test_deque.py index 45ee189..1d3f726 100644 --- a/Lib/test/test_deque.py +++ b/Lib/test/test_deque.py @@ -234,7 +234,7 @@ class TestBasic(unittest.TestCase): d = deque(data[:i]) r = d.reverse() self.assertEqual(list(d), list(reversed(data[:i]))) - self.assert_(r is None) + self.assertIs(r, None) d.reverse() self.assertEqual(list(d), data[:i]) self.assertRaises(TypeError, d.reverse, 1) # Arity is zero diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py index 7e9b62b..414913d 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -4534,11 +4534,11 @@ order (MRO) for bases """ __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): @@ -4565,7 +4565,7 @@ class DictProxyTests(unittest.TestCase): # Testing dict-proxy iterkeys... keys = [ key for key in self.C.__dict__.iterkeys() ] 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_dircache.py b/Lib/test/test_dircache.py index 8a80720..c6ad31c 100644 --- a/Lib/test/test_dircache.py +++ b/Lib/test/test_dircache.py @@ -35,7 +35,7 @@ class DircacheTests(unittest.TestCase): def test_listdir(self): ## SUCCESSFUL CASES entries = dircache.listdir(self.tempdir) - self.assertEquals(entries, []) + self.assertEqual(entries, []) # Check that cache is actually caching, not just passing through. self.assertTrue(dircache.listdir(self.tempdir) is entries) @@ -52,7 +52,7 @@ class DircacheTests(unittest.TestCase): time.sleep(1) self.writeTemp("test1") entries = dircache.listdir(self.tempdir) - self.assertEquals(entries, ['test1']) + self.assertEqual(entries, ['test1']) self.assertTrue(dircache.listdir(self.tempdir) is entries) ## UNSUCCESSFUL CASES @@ -63,7 +63,7 @@ class DircacheTests(unittest.TestCase): self.mkdirTemp("A") lst = ['A', 'test2', 'test_nonexistent'] dircache.annotate(self.tempdir, lst) - self.assertEquals(lst, ['A/', 'test2', 'test_nonexistent']) + self.assertEqual(lst, ['A/', 'test2', 'test_nonexistent']) def test_main(): diff --git a/Lib/test/test_epoll.py b/Lib/test/test_epoll.py index b50db23..216e2c7 100644 --- a/Lib/test/test_epoll.py +++ b/Lib/test/test_epoll.py @@ -56,7 +56,7 @@ class TestEPoll(unittest.TestCase): try: client.connect(('127.0.0.1', self.serverSocket.getsockname()[1])) except socket.error, 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() @@ -162,7 +162,7 @@ class TestEPoll(unittest.TestCase): (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() @@ -183,7 +183,7 @@ class TestEPoll(unittest.TestCase): (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) @@ -193,7 +193,7 @@ class TestEPoll(unittest.TestCase): 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 3ee0856..a19c82d 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -32,8 +32,8 @@ class ExceptionTests(unittest.TestCase): raise exc("spam") except exc, 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") @@ -163,7 +163,7 @@ class ExceptionTests(unittest.TestCase): except TypeError, 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'+os.extsep+'py')) else: self.fail("Expected exception") @@ -175,10 +175,10 @@ class ExceptionTests(unittest.TestCase): except RuntimeError, 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'+os.extsep+'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") @@ -284,14 +284,14 @@ class ExceptionTests(unittest.TestCase): if type(e) is not exc: raise # Verify module name - self.assertEquals(type(e).__module__, 'exceptions') + self.assertEqual(type(e).__module__, 'exceptions') # Verify no ref leaks in Exc_str() s = str(e) for checkArgName in expected: - self.assertEquals(repr(getattr(e, checkArgName)), - repr(expected[checkArgName]), - 'exception "%s", attribute "%s"' % - (repr(e), checkArgName)) + self.assertEqual(repr(getattr(e, checkArgName)), + repr(expected[checkArgName]), + 'exception "%s", attribute "%s"' % + (repr(e), checkArgName)) # test for pickling support for p in pickle, cPickle: @@ -300,9 +300,9 @@ class ExceptionTests(unittest.TestCase): 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 testDeprecatedMessageAttribute(self): @@ -359,7 +359,7 @@ class ExceptionTests(unittest.TestCase): 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(): diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py index c3c0def..dffa4b5 100644 --- a/Lib/test/test_file.py +++ b/Lib/test/test_file.py @@ -30,7 +30,7 @@ class AutoFileTests(unittest.TestCase): # 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') @@ -49,7 +49,7 @@ class AutoFileTests(unittest.TestCase): 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 @@ -66,7 +66,7 @@ class AutoFileTests(unittest.TestCase): 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 @@ -87,7 +87,7 @@ class AutoFileTests(unittest.TestCase): 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) @@ -124,12 +124,12 @@ class AutoFileTests(unittest.TestCase): 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) @@ -195,7 +195,7 @@ class OtherFileTests(unittest.TestCase): 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_file2k.py b/Lib/test/test_file2k.py index ab09f21..399f119 100644 --- a/Lib/test/test_file2k.py +++ b/Lib/test/test_file2k.py @@ -29,7 +29,7 @@ class AutoFileTests(unittest.TestCase): # verify weak references p = proxy(self.f) p.write('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') @@ -58,7 +58,7 @@ class AutoFileTests(unittest.TestCase): a = array('c', 'x'*10) self.f = open(TESTFN, 'rb') n = self.f.readinto(a) - self.assertEquals('12', a.tostring()[:n]) + self.assertEqual('12', a.tostring()[:n]) def testWritelinesUserList(self): # verify writelines with instance sequence @@ -67,7 +67,7 @@ class AutoFileTests(unittest.TestCase): self.f.close() self.f = open(TESTFN, 'rb') buf = self.f.read() - self.assertEquals(buf, '12') + self.assertEqual(buf, '12') def testWritelinesIntegers(self): # verify writelines with integers @@ -94,7 +94,7 @@ class AutoFileTests(unittest.TestCase): self.f.close() self.f = open(TESTFN, 'rb') f = self.f - self.assertEquals(f.name, TESTFN) + self.assertEqual(f.name, TESTFN) self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) @@ -125,12 +125,12 @@ class AutoFileTests(unittest.TestCase): self.assertRaises(ValueError, self.f.writelines, []) # 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) @@ -261,7 +261,7 @@ class OtherFileTests(unittest.TestCase): f.close() except IOError, msg: self.fail('error setting buffer size %d: %s' % (s, str(msg))) - self.assertEquals(d, s) + self.assertEqual(d, s) def testTruncateOnWindows(self): os.unlink(TESTFN) @@ -621,7 +621,7 @@ class StdoutTests(unittest.TestCase): try: print except RuntimeError as e: - self.assertEquals(str(e), "lost sys.stdout") + self.assertEqual(str(e), "lost sys.stdout") else: self.fail("Expected RuntimeError") finally: diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py index a63ba06..9688ffc 100644 --- a/Lib/test/test_fileio.py +++ b/Lib/test/test_fileio.py @@ -31,31 +31,31 @@ class AutoFileTests(unittest.TestCase): # 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': @@ -69,7 +69,7 @@ class AutoFileTests(unittest.TestCase): a = array(b'b', b'x'*10) self.f = _FileIO(TESTFN, 'r') n = self.f.readinto(a) - self.assertEquals(array(b'b', [1, 2]), a[:n]) + self.assertEqual(array(b'b', [1, 2]), a[:n]) def test_none_args(self): self.f.write(b"hi\nbye\nabc") @@ -81,19 +81,19 @@ class AutoFileTests(unittest.TestCase): self.assertEqual(self.f.readlines(None), [b"bye\n", b"abc"]) def testRepr(self): - self.assertEquals(repr(self.f), "<_io.FileIO name=%r mode='%s'>" - % (self.f.name, self.f.mode)) + self.assertEqual(repr(self.f), "<_io.FileIO name=%r mode='%s'>" + % (self.f.name, self.f.mode)) del self.f.name - self.assertEquals(repr(self.f), "<_io.FileIO fd=%r mode='%s'>" - % (self.f.fileno(), self.f.mode)) + self.assertEqual(repr(self.f), "<_io.FileIO fd=%r mode='%s'>" + % (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) @@ -236,22 +236,22 @@ class OtherFileTests(unittest.TestCase): 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": @@ -263,14 +263,14 @@ class OtherFileTests(unittest.TestCase): # 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) @@ -304,7 +304,7 @@ class OtherFileTests(unittest.TestCase): 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 de5ca46..9d68da7 100644 --- a/Lib/test/test_float.py +++ b/Lib/test/test_float.py @@ -473,15 +473,15 @@ class IEEEFormatTestCase(unittest.TestCase): 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()) @requires_IEEE_754 def test_underflow_sign(self): # check that -1e-1000 gives -0.0, not 0.0 - self.assertEquals(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1)) - self.assertEquals(math.atan2(float('-1e-1000'), -1), - math.atan2(-0.0, -1)) + self.assertEqual(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1)) + self.assertEqual(math.atan2(float('-1e-1000'), -1), + math.atan2(-0.0, -1)) def test_format(self): # these should be rewritten to use both format(x, spec) and @@ -556,9 +556,9 @@ class IEEEFormatTestCase(unittest.TestCase): self.assertEqual(fmt % -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_fpformat.py b/Lib/test/test_fpformat.py index a951cd0..e6de3b0 100644 --- a/Lib/test/test_fpformat.py +++ b/Lib/test/test_fpformat.py @@ -26,7 +26,7 @@ class FpformatTest(unittest.TestCase): n = repr(n) expected = "%.*f" % (digits, float(n)) - self.assertEquals(result, expected) + self.assertEqual(result, expected) def checkSci(self, n, digits): result = sci(n, digits) @@ -39,11 +39,11 @@ class FpformatTest(unittest.TestCase): exp = exp[0] + "0" + exp[1:] expected = "%se%s" % (num, exp) - self.assertEquals(result, expected) + self.assertEqual(result, expected) def test_basic_cases(self): - self.assertEquals(fix(100.0/3, 3), '33.333') - self.assertEquals(sci(100.0/3, 3), '3.333e+001') + self.assertEqual(fix(100.0/3, 3), '33.333') + self.assertEqual(sci(100.0/3, 3), '3.333e+001') def test_reasonable_values(self): for d in range(7): @@ -54,12 +54,12 @@ class FpformatTest(unittest.TestCase): def test_failing_values(self): # Now for 'unreasonable n and d' - self.assertEquals(fix(1.0, 1000), '1.'+('0'*1000)) - self.assertEquals(sci("1"+('0'*1000), 0), '1e+1000') + self.assertEqual(fix(1.0, 1000), '1.'+('0'*1000)) + self.assertEqual(sci("1"+('0'*1000), 0), '1e+1000') # This behavior is inconsistent. sci raises an exception; fix doesn't. yacht = "Throatwobbler Mangrove" - self.assertEquals(fix(yacht, 10), yacht) + self.assertEqual(fix(yacht, 10), yacht) try: sci(yacht, 10) except NotANumber: diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py index 7f0c428..a798477 100644 --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -91,16 +91,16 @@ class DummyRational(object): 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): @@ -111,8 +111,8 @@ class FractionTest(unittest.TestCase): 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): @@ -120,25 +120,25 @@ class FractionTest(unittest.TestCase): try: callable(*args, **kwargs) except exc_type, 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) @@ -150,43 +150,43 @@ class FractionTest(unittest.TestCase): @requires_IEEE_754 def testInitFromFloat(self): - self.assertEquals((5, 2), _components(F(2.5))) - self.assertEquals((0, 1), _components(F(-0.0))) - self.assertEquals((3602879701896397, 36028797018963968), - _components(F(0.1))) + self.assertEqual((5, 2), _components(F(2.5))) + self.assertEqual((0, 1), _components(F(-0.0))) + self.assertEqual((3602879701896397, 36028797018963968), + _components(F(0.1))) self.assertRaises(TypeError, F, float('nan')) self.assertRaises(TypeError, F, float('inf')) self.assertRaises(TypeError, F, float('-inf')) def testInitFromDecimal(self): - self.assertEquals((11, 10), - _components(F(Decimal('1.1')))) - self.assertEquals((7, 200), - _components(F(Decimal('3.5e-2')))) - self.assertEquals((0, 1), - _components(F(Decimal('.000e20')))) + self.assertEqual((11, 10), + _components(F(Decimal('1.1')))) + self.assertEqual((7, 200), + _components(F(Decimal('3.5e-2')))) + self.assertEqual((0, 1), + _components(F(Decimal('.000e20')))) self.assertRaises(TypeError, F, Decimal('nan')) self.assertRaises(TypeError, F, Decimal('snan')) self.assertRaises(TypeError, F, Decimal('inf')) self.assertRaises(TypeError, F, Decimal('-inf')) 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((13, 2), _components(F(u" 013/02 \n "))) - - self.assertEquals((16, 5), _components(F(" 3.2 "))) - self.assertEquals((-16, 5), _components(F(u" -3.2 "))) - self.assertEquals((-3, 1), _components(F(u" -3. "))) - self.assertEquals((3, 5), _components(F(u" .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((13, 2), _components(F(u" 013/02 \n "))) + + self.assertEqual((16, 5), _components(F(" 3.2 "))) + self.assertEqual((-16, 5), _components(F(u" -3.2 "))) + self.assertEqual((-3, 1), _components(F(u" -3. "))) + self.assertEqual((3, 5), _components(F(u" .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( @@ -229,33 +229,33 @@ class FractionTest(unittest.TestCase): 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), - _components(F.from_float(1e23))) - self.assertEquals(float(10**23), float(F.from_float(1e23))) - self.assertEquals((3602879701896397, 1125899906842624), - _components(F.from_float(3.2))) - self.assertEquals(3.2, float(F.from_float(3.2))) + 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.assertEqual(float(10**23), float(F.from_float(1e23))) + self.assertEqual((3602879701896397, 1125899906842624), + _components(F.from_float(3.2))) + self.assertEqual(3.2, float(F.from_float(3.2))) inf = 1e1000 nan = inf - inf @@ -271,13 +271,13 @@ class FractionTest(unittest.TestCase): 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.", @@ -306,29 +306,29 @@ class FractionTest(unittest.TestCase): self.assertTypedEquals(-1, math.trunc(F(-11, 10))) self.assertTypedEquals(-1, int(F(-11, 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, long('2'*400+'7')) - self.assertAlmostEquals(2.0/3, + self.assertAlmostEqual(2.0/3, float(F(long('2'*400+'7'), long('3'*400+'1')))) self.assertTypedEquals(0.1+0j, complex(F(1,10))) 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)) # Will return 1j in 3.0: self.assertRaises(ValueError, pow, F(-1), F(1, 2)) @@ -394,7 +394,7 @@ class FractionTest(unittest.TestCase): 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)) @@ -529,18 +529,18 @@ class FractionTest(unittest.TestCase): self.assertFalse(float('-inf') == F(2, 5)) def testStringification(self): - self.assertEquals("Fraction(7, 3)", repr(F(7, 3))) - self.assertEquals("Fraction(6283185307, 2000000000)", - repr(F('3.1415926535'))) - self.assertEquals("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("Fraction(7, 3)", repr(F(7, 3))) + self.assertEqual("Fraction(6283185307, 2000000000)", + repr(F('3.1415926535'))) + self.assertEqual("Fraction(-1, 100000000000000000000)", + repr(F(1, -10**20))) + 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 @@ -553,7 +553,7 @@ class FractionTest(unittest.TestCase): 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 @@ -567,7 +567,7 @@ class FractionTest(unittest.TestCase): 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 7fb53a4..771f599 100644 --- a/Lib/test/test_frozen.py +++ b/Lib/test/test_frozen.py @@ -30,8 +30,8 @@ class FrozenTests(unittest.TestCase): else: self.fail("import __phello__.foo should have failed") - self.assertEquals(stdout.getvalue(), - 'Hello world...\nHello world...\nHello world...\n') + self.assertEqual(stdout.getvalue(), + 'Hello world...\nHello world...\nHello world...\n') del sys.modules['__hello__'] del sys.modules['__phello__'] diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py index c5beba1..6bc7b2b 100644 --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -361,12 +361,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __lt__(self, other): return self.value < other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_le(self): @functools.total_ordering @@ -375,12 +375,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __le__(self, other): return self.value <= other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_gt(self): @functools.total_ordering @@ -389,12 +389,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __gt__(self, other): return self.value > other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_ge(self): @functools.total_ordering @@ -403,24 +403,24 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __ge__(self, other): return self.value >= other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_no_overwrite(self): # new methods should not overwrite existing @functools.total_ordering class A(str): pass - self.assert_(A("a") < A("b")) - self.assert_(A("b") > A("a")) - self.assert_(A("a") <= A("b")) - self.assert_(A("b") >= A("a")) - self.assert_(A("b") <= A("b")) - self.assert_(A("b") >= A("b")) + self.assertTrue(A("a") < A("b")) + self.assertTrue(A("b") > A("a")) + self.assertTrue(A("a") <= A("b")) + self.assertTrue(A("b") >= A("a")) + self.assertTrue(A("b") <= A("b")) + self.assertTrue(A("b") >= A("b")) def test_no_operations_defined(self): with self.assertRaises(ValueError): diff --git a/Lib/test/test_gdb.py b/Lib/test/test_gdb.py index 3ade185..e033dcf 100644 --- a/Lib/test/test_gdb.py +++ b/Lib/test/test_gdb.py @@ -127,7 +127,7 @@ class DebuggerTests(unittest.TestCase): '') # Ensure no unexpected error messages: - self.assertEquals(err, '') + self.assertEqual(err, '') return out @@ -155,13 +155,12 @@ class DebuggerTests(unittest.TestCase): def assertEndsWith(self, actual, exp_end): '''Ensure that the given "actual" string ends with "exp_end"''' - self.assert_(actual.endswith(exp_end), - msg='%r did not end with %r' % (actual, exp_end)) + self.assertTrue(actual.endswith(exp_end), + msg='%r did not end with %r' % (actual, exp_end)) def assertMultilineMatches(self, actual, pattern): m = re.match(pattern, actual, re.DOTALL) - self.assert_(m, - msg='%r did not match %r' % (actual, pattern)) + self.assertTrue(m, msg='%r did not match %r' % (actual, pattern)) def get_sample_script(self): return findfile('gdb_sample.py') @@ -176,7 +175,7 @@ class PrettyPrintTests(DebuggerTests): # matches repr(value) in this process: gdb_repr, gdb_output = self.get_gdb_repr('print ' + repr(val), cmds_after_breakpoint) - self.assertEquals(gdb_repr, repr(val), gdb_output) + self.assertEqual(gdb_repr, repr(val), gdb_output) def test_int(self): 'Verify the pretty-printing of various "int" values' @@ -258,7 +257,7 @@ class PrettyPrintTests(DebuggerTests): gdb_repr, gdb_output = self.get_gdb_repr('''s = set(['a','b']) s.pop() print s''') - self.assertEquals(gdb_repr, "set(['b'])") + self.assertEqual(gdb_repr, "set(['b'])") def test_frozensets(self): 'Verify the pretty-printing of frozensets' @@ -274,8 +273,8 @@ try: except RuntimeError, e: print e ''') - self.assertEquals(gdb_repr, - "exceptions.RuntimeError('I am an error',)") + self.assertEqual(gdb_repr, + "exceptions.RuntimeError('I am an error',)") # Test division by zero: @@ -285,8 +284,8 @@ try: except ZeroDivisionError, e: print e ''') - self.assertEquals(gdb_repr, - "exceptions.ZeroDivisionError('integer division or modulo by zero',)") + self.assertEqual(gdb_repr, + "exceptions.ZeroDivisionError('integer division or modulo by zero',)") def test_classic_class(self): 'Verify the pretty-printing of classic class instances' @@ -380,7 +379,7 @@ print foo''') 'backtrace']) ) - self.assertEquals(gdb_repr, '0x0') + self.assertEqual(gdb_repr, '0x0') def test_NULL_ob_type(self): 'Ensure that a PyObject* with NULL ob_type is handled gracefully' @@ -432,12 +431,12 @@ print foo''', gdb_repr, gdb_output = \ self.get_gdb_repr("a = [3, 4, 5] ; a.append(a) ; print a") - self.assertEquals(gdb_repr, '[3, 4, 5, [...]]') + self.assertEqual(gdb_repr, '[3, 4, 5, [...]]') gdb_repr, gdb_output = \ self.get_gdb_repr("a = [3, 4, 5] ; b = [a] ; a.append(b) ; print a") - self.assertEquals(gdb_repr, '[3, 4, 5, [[...]]]') + self.assertEqual(gdb_repr, '[3, 4, 5, [[...]]]') def test_selfreferential_dict(self): '''Ensure that a reference loop involving a dict doesn't lead proxyval @@ -445,7 +444,7 @@ print foo''', gdb_repr, gdb_output = \ self.get_gdb_repr("a = {} ; b = {'bar':a} ; a['foo'] = b ; print a") - self.assertEquals(gdb_repr, "{'foo': {'bar': {...}}}") + self.assertEqual(gdb_repr, "{'foo': {'bar': {...}}}") def test_selfreferential_old_style_instance(self): gdb_repr, gdb_output = \ @@ -490,34 +489,34 @@ print a''') def test_truncation(self): 'Verify that very long output is truncated' gdb_repr, gdb_output = self.get_gdb_repr('print range(1000)') - self.assertEquals(gdb_repr, - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " - "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " - "27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " - "40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " - "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " - "66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " - "79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " - "92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " - "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " - "114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " - "124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " - "134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " - "144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " - "154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " - "164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " - "174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " - "184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " - "194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " - "204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " - "214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " - "224, 225, 226...(truncated)") - self.assertEquals(len(gdb_repr), - 1024 + len('...(truncated)')) + self.assertEqual(gdb_repr, + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " + "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " + "27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " + "40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " + "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " + "66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " + "79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " + "92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " + "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " + "114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " + "124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " + "134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " + "144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " + "154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " + "164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " + "174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " + "184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " + "194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " + "204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " + "214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " + "224, 225, 226...(truncated)") + self.assertEqual(len(gdb_repr), + 1024 + len('...(truncated)')) def test_builtin_function(self): gdb_repr, gdb_output = self.get_gdb_repr('print len') - self.assertEquals(gdb_repr, '<built-in function len>') + self.assertEqual(gdb_repr, '<built-in function len>') def test_builtin_method(self): gdb_repr, gdb_output = self.get_gdb_repr('import sys; print sys.stdout.readlines') diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py index 423217b..d06296b 100644 --- a/Lib/test/test_getargs2.py +++ b/Lib/test/test_getargs2.py @@ -262,7 +262,7 @@ class Tuple_TestCase(unittest.TestCase): 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: @@ -275,25 +275,25 @@ class Tuple_TestCase(unittest.TestCase): 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) ) @@ -302,14 +302,14 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords(arg1=(1,2)) except TypeError, 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, 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): @@ -317,7 +317,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords((1,2),3,arg5=10,arg666=666) except TypeError, 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 7186c7f..f924287 100644 --- a/Lib/test/test_getopt.py +++ b/Lib/test/test_getopt.py @@ -175,9 +175,9 @@ class GetoptTests(unittest.TestCase): 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 1ad59e8..692322d 100644 --- a/Lib/test/test_glob.py +++ b/Lib/test/test_glob.py @@ -59,8 +59,8 @@ class GlobTests(unittest.TestCase): if set(type(x) for x in tmp) == uniset: u1 = glob.glob(u'*') u2 = glob.glob(u'./*') - 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_gzip.py b/Lib/test/test_gzip.py index baa38d4..573879e 100644 --- a/Lib/test/test_gzip.py +++ b/Lib/test/test_gzip.py @@ -102,7 +102,7 @@ class TestGzip(unittest.TestCase): ztxt = zgfile.read(8192) contents += ztxt if not ztxt: break - self.assertEquals(contents, 'a'*201) + self.assertEqual(contents, 'a'*201) def test_buffered_reader(self): # Issue #7471: a GzipFile can be wrapped in a BufferedReader for @@ -166,7 +166,7 @@ class TestGzip(unittest.TestCase): f.read(10) f.seek(10, whence=1) y = f.read(10) - 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_htmllib.py b/Lib/test/test_htmllib.py index e1f4334..03813b0 100644 --- a/Lib/test/test_htmllib.py +++ b/Lib/test/test_htmllib.py @@ -38,11 +38,11 @@ class HTMLParserTestCase(unittest.TestCase): <a name='frob'> </a> """) parser.close() - self.assertEquals(parser.get_anchor_info(), - [('http://foo.org/', 'splat', ''), - ('http://www.python.org/', '', ''), - ('', 'frob', ''), - ]) + self.assertEqual(parser.get_anchor_info(), + [('http://foo.org/', 'splat', ''), + ('http://www.python.org/', '', ''), + ('', 'frob', ''), + ]) def test_decl_collection(self): # See SF patch #545300 @@ -56,10 +56,10 @@ class HTMLParserTestCase(unittest.TestCase): </html> """) parser.close() - self.assertEquals(parser.get_decl_info(), - ["if !supportEmptyParas", - "endif" - ]) + self.assertEqual(parser.get_decl_info(), + ["if !supportEmptyParas", + "endif" + ]) def test_main(): test_support.run_unittest(HTMLParserTestCase) diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py index d7b73e1..bb6d3cf 100644 --- a/Lib/test/test_httplib.py +++ b/Lib/test/test_httplib.py @@ -135,7 +135,7 @@ class BasicTest(TestCase): def test_bad_status_repr(self): exc = httplib.BadStatusLine('') - self.assertEquals(repr(exc), '''BadStatusLine("\'\'",)''') + self.assertEqual(repr(exc), '''BadStatusLine("\'\'",)''') def test_partial_reads(self): # if we have a lenght, the system knows when to close itself @@ -216,13 +216,13 @@ class BasicTest(TestCase): sock = FakeSocket(None) conn.sock = sock conn.send(expected) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = '' conn.send(array.array('c', expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = '' conn.send(StringIO.StringIO(expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) def test_chunked(self): chunked_start = ( @@ -236,7 +236,7 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = httplib.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), 'hello world') + self.assertEqual(resp.read(), 'hello world') resp.close() for x in ('', 'foo\r\n'): @@ -246,7 +246,7 @@ class BasicTest(TestCase): try: resp.read() except httplib.IncompleteRead, i: - self.assertEquals(i.partial, 'hello world') + self.assertEqual(i.partial, 'hello world') self.assertEqual(repr(i),'IncompleteRead(11 bytes read)') self.assertEqual(str(i),'IncompleteRead(11 bytes read)') else: @@ -266,9 +266,9 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = httplib.HTTPResponse(sock, method="HEAD") resp.begin() - self.assertEquals(resp.read(), '') - self.assertEquals(resp.status, 200) - self.assertEquals(resp.reason, 'OK') + self.assertEqual(resp.read(), '') + self.assertEqual(resp.status, 200) + self.assertEqual(resp.reason, 'OK') self.assertTrue(resp.isclosed()) def test_negative_content_length(self): @@ -276,7 +276,7 @@ class BasicTest(TestCase): 'Content-Length: -1\r\n\r\nHello\r\n') resp = httplib.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), 'Hello\r\n') + self.assertEqual(resp.read(), 'Hello\r\n') resp.close() def test_incomplete_read(self): @@ -286,7 +286,7 @@ class BasicTest(TestCase): try: resp.read() except httplib.IncompleteRead as i: - self.assertEquals(i.partial, 'Hello\r\n') + self.assertEqual(i.partial, 'Hello\r\n') self.assertEqual(repr(i), "IncompleteRead(7 bytes read, 3 more expected)") self.assertEqual(str(i), @@ -321,7 +321,7 @@ class BasicTest(TestCase): class OfflineTest(TestCase): def test_responses(self): - self.assertEquals(httplib.responses[httplib.NOT_FOUND], "Not Found") + self.assertEqual(httplib.responses[httplib.NOT_FOUND], "Not Found") class SourceAddressTest(TestCase): diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py index 00db29d..15b0ea0 100644 --- a/Lib/test/test_imaplib.py +++ b/Lib/test/test_imaplib.py @@ -112,7 +112,7 @@ class BaseThreadedNetworkedTests(unittest.TestCase): 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_inspect.py b/Lib/test/test_inspect.py index 08630a5..fcdfd94 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -384,8 +384,8 @@ class TestBuggyCases(GetSourceBase): 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 6e611c2..fa46212 100644 --- a/Lib/test/test_int.py +++ b/Lib/test/test_int.py @@ -392,7 +392,7 @@ class IntTestCases(unittest.TestCase): 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 2b4a3a9..ad2919b 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -606,7 +606,7 @@ class CommonBufferedTests: 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 @@ -711,36 +711,36 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): 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) @@ -748,24 +748,24 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): 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" @@ -782,34 +782,34 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): 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()) @unittest.skipUnless(threading, 'Threading required for this test.') @support.requires_resource('cpu') @@ -936,15 +936,15 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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() @@ -986,11 +986,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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, + self.assertEqual(contents, b"".join(writer._write_stack)) def test_writes(self): @@ -1020,11 +1020,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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") @@ -1034,11 +1034,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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) @@ -1061,7 +1061,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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() @@ -1069,7 +1069,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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. @@ -1128,7 +1128,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): 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) @@ -1329,45 +1329,45 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): 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)) @@ -1399,8 +1399,8 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): 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) @@ -1625,12 +1625,12 @@ class StatefulIncrementalDecoderTest(unittest.TestCase): # 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): @@ -1647,12 +1647,12 @@ class TextIOWrapperTest(unittest.TestCase): 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') @@ -1688,11 +1688,11 @@ class TextIOWrapperTest(unittest.TestCase): 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 @@ -1715,11 +1715,11 @@ class TextIOWrapperTest(unittest.TestCase): # (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 @@ -1736,14 +1736,14 @@ class TextIOWrapperTest(unittest.TestCase): 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" ] @@ -1778,14 +1778,14 @@ class TextIOWrapperTest(unittest.TestCase): 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" @@ -1799,9 +1799,9 @@ class TextIOWrapperTest(unittest.TestCase): ]: 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 = { @@ -1818,8 +1818,8 @@ class TextIOWrapperTest(unittest.TestCase): 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 = [] @@ -1833,7 +1833,7 @@ class TextIOWrapperTest(unittest.TestCase): t.write("abc") del t support.gc_collect() - self.assertEquals([b"abc"], l) + self.assertEqual([b"abc"], l) def test_override_destructor(self): record = [] @@ -1880,26 +1880,26 @@ class TextIOWrapperTest(unittest.TestCase): 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() @@ -1924,7 +1924,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -1934,16 +1934,16 @@ class TextIOWrapperTest(unittest.TestCase): 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): @@ -1951,7 +1951,7 @@ class TextIOWrapperTest(unittest.TestCase): 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 @@ -1960,9 +1960,9 @@ class TextIOWrapperTest(unittest.TestCase): f.close() f = self.open(support.TESTFN, "r", encoding="utf-8") s = f.read(prefix_size) - self.assertEquals(s, prefix.decode("ascii")) - self.assertEquals(f.tell(), prefix_size) - self.assertEquals(f.readline(), u_suffix) + self.assertEqual(s, prefix.decode("ascii")) + self.assertEqual(f.tell(), prefix_size) + self.assertEqual(f.readline(), u_suffix) def test_seeking_too(self): # Regression test for a specific bug @@ -1995,11 +1995,11 @@ class TextIOWrapperTest(unittest.TestCase): 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. @@ -2038,10 +2038,10 @@ class TextIOWrapperTest(unittest.TestCase): 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): @@ -2058,7 +2058,7 @@ class TextIOWrapperTest(unittest.TestCase): 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")) @@ -2078,7 +2078,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -2090,7 +2090,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -2102,7 +2102,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -2113,7 +2113,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -2121,7 +2121,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -2131,7 +2131,7 @@ class TextIOWrapperTest(unittest.TestCase): 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) @@ -2147,12 +2147,12 @@ class TextIOWrapperTest(unittest.TestCase): 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 @@ -2167,7 +2167,7 @@ class TextIOWrapperTest(unittest.TestCase): 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: @@ -2195,7 +2195,7 @@ class TextIOWrapperTest(unittest.TestCase): 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") @@ -2249,9 +2249,9 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): 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") @@ -2300,24 +2300,24 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): # 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 = ( @@ -2338,11 +2338,11 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): 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) @@ -2375,28 +2375,28 @@ class MiscIOTest(unittest.TestCase): 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 48857df..ae965d8 100644 --- a/Lib/test/test_ioctl.py +++ b/Lib/test/test_ioctl.py @@ -50,7 +50,7 @@ class IoctlTests(unittest.TestCase): 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.assertIn(rpgrp, ids) def test_ioctl_mutate(self): diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index e91ac28..2ef35d6 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -192,7 +192,7 @@ class TestBasicOps(unittest.TestCase): 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 @@ -288,20 +288,20 @@ class TestBasicOps(unittest.TestCase): 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, filter(set(cwr).__contains__, perm)) # comb: perm that is a cwr diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py index a1f3cbe..e5eecfa 100644 --- a/Lib/test/test_kqueue.py +++ b/Lib/test/test_kqueue.py @@ -90,7 +90,7 @@ class TestKQueue(unittest.TestCase): try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except socket.error, 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 @@ -124,7 +124,7 @@ class TestKQueue(unittest.TestCase): 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)]) @@ -143,7 +143,7 @@ class TestKQueue(unittest.TestCase): 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), @@ -166,7 +166,7 @@ class TestKQueue(unittest.TestCase): 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() @@ -183,7 +183,7 @@ class TestKQueue(unittest.TestCase): 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 88346be..407bebc 100644 --- a/Lib/test/test_linecache.py +++ b/Lib/test/test_linecache.py @@ -42,31 +42,31 @@ class LineCacheTests(unittest.TestCase): 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 @@ class LineCacheTests(unittest.TestCase): # 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 @@ -104,7 +104,7 @@ class LineCacheTests(unittest.TestCase): 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: @@ -115,13 +115,13 @@ class LineCacheTests(unittest.TestCase): # 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) def test_main(): diff --git a/Lib/test/test_linuxaudiodev.py b/Lib/test/test_linuxaudiodev.py index 3772a58..fef46b4 100644 --- a/Lib/test/test_linuxaudiodev.py +++ b/Lib/test/test_linuxaudiodev.py @@ -61,29 +61,29 @@ class LinuxAudioDevTests(unittest.TestCase): try: self.dev.setparameters(-1, size, nchannels, fmt) except ValueError, err: - self.assertEquals(err.args[0], "expected rate >= 0, not -1") + self.assertEqual(err.args[0], "expected rate >= 0, not -1") try: self.dev.setparameters(rate, -2, nchannels, fmt) except ValueError, err: - self.assertEquals(err.args[0], "expected sample size >= 0, not -2") + self.assertEqual(err.args[0], "expected sample size >= 0, not -2") try: self.dev.setparameters(rate, size, 3, fmt) except ValueError, err: - self.assertEquals(err.args[0], "nchannels must be 1 or 2, not 3") + self.assertEqual(err.args[0], "nchannels must be 1 or 2, not 3") try: self.dev.setparameters(rate, size, nchannels, 177) except ValueError, err: - self.assertEquals(err.args[0], "unknown audio encoding: 177") + self.assertEqual(err.args[0], "unknown audio encoding: 177") try: self.dev.setparameters(rate, size, nchannels, linuxaudiodev.AFMT_U16_LE) except ValueError, err: - self.assertEquals(err.args[0], "for linear unsigned 16-bit little-endian " - "audio, expected sample size 16, not 8") + self.assertEqual(err.args[0], "for linear unsigned 16-bit little-endian " + "audio, expected sample size 16, not 8") try: self.dev.setparameters(rate, 16, nchannels, fmt) except ValueError, err: - self.assertEquals(err.args[0], "for linear unsigned 8-bit audio, expected " - "sample size 8, not 16") + self.assertEqual(err.args[0], "for linear unsigned 8-bit audio, expected " + "sample size 8, not 16") def test_main(): try: diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py index ed17d15..9f8374a 100644 --- a/Lib/test/test_logging.py +++ b/Lib/test/test_logging.py @@ -120,13 +120,13 @@ class BaseTest(unittest.TestCase): 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) @@ -692,7 +692,7 @@ class ConfigFileTest(BaseTest): 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([]) @@ -811,7 +811,7 @@ class SocketHandlerTest(BaseTest): 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): @@ -1527,7 +1527,7 @@ class ConfigDictTest(BaseTest): 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([]) @@ -1542,7 +1542,7 @@ class ConfigDictTest(BaseTest): 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([]) diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py index 9706a8e..58cfc3a 100644 --- a/Lib/test/test_long.py +++ b/Lib/test/test_long.py @@ -530,9 +530,9 @@ class LongTest(unittest.TestCase): try: long(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_macos.py b/Lib/test/test_macos.py index 465d304..5af5105 100644 --- a/Lib/test/test_macos.py +++ b/Lib/test/test_macos.py @@ -23,8 +23,8 @@ class TestMacOS(unittest.TestCase): test_support.TESTFN]) cr, tp = MacOS.GetCreatorAndType(test_support.TESTFN) - self.assertEquals(tp, 'ABCD') - self.assertEquals(cr, 'EFGH') + self.assertEqual(tp, 'ABCD') + self.assertEqual(cr, 'EFGH') finally: os.unlink(test_support.TESTFN) @@ -42,8 +42,8 @@ class TestMacOS(unittest.TestCase): 'ABCD', 'EFGH') cr, tp = MacOS.GetCreatorAndType(test_support.TESTFN) - self.assertEquals(cr, 'ABCD') - self.assertEquals(tp, 'EFGH') + self.assertEqual(cr, 'ABCD') + self.assertEqual(tp, 'EFGH') data = subprocess.Popen(["/Developer/Tools/GetFileInfo", test_support.TESTFN], stdout=subprocess.PIPE).communicate()[0] @@ -56,8 +56,8 @@ class TestMacOS(unittest.TestCase): if ln.startswith('creator:'): cr = ln.split()[-1][1:-1] - self.assertEquals(cr, 'ABCD') - self.assertEquals(tp, 'EFGH') + self.assertEqual(cr, 'ABCD') + self.assertEqual(tp, 'EFGH') finally: os.unlink(test_support.TESTFN) @@ -77,14 +77,14 @@ class TestMacOS(unittest.TestCase): fp = open(test_support.TESTFN, 'r') data = fp.read() fp.close() - self.assertEquals(data, 'hello world\n') + self.assertEqual(data, 'hello world\n') rfp = MacOS.openrf(test_support.TESTFN, '*rb') data = rfp.read(100) data2 = rfp.read(100) rfp.close() - self.assertEquals(data, 'goodbye world\n') - self.assertEquals(data2, '') + self.assertEqual(data, 'goodbye world\n') + self.assertEqual(data2, '') finally: diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index 7e21862..10a5161 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -210,8 +210,8 @@ class BugsTestCase(unittest.TestCase): 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 7d49ed9..973d1ab 100644 --- a/Lib/test/test_math.py +++ b/Lib/test/test_math.py @@ -158,7 +158,7 @@ class MathTests(unittest.TestCase): 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))) @@ -176,8 +176,8 @@ class MathTests(unittest.TestCase): 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): @@ -264,17 +264,17 @@ class MathTests(unittest.TestCase): def testCeil(self): self.assertRaises(TypeError, math.ceil) # These types will be int in py3k. - self.assertEquals(float, type(math.ceil(1))) - self.assertEquals(float, type(math.ceil(1L))) - self.assertEquals(float, type(math.ceil(1.0))) + self.assertEqual(float, type(math.ceil(1))) + self.assertEqual(float, type(math.ceil(1L))) + self.assertEqual(float, type(math.ceil(1.0))) 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(object): @@ -300,19 +300,19 @@ class MathTests(unittest.TestCase): 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))) @@ -322,7 +322,7 @@ class MathTests(unittest.TestCase): # 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) @@ -342,8 +342,8 @@ class MathTests(unittest.TestCase): 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): @@ -357,8 +357,8 @@ class MathTests(unittest.TestCase): 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): @@ -384,9 +384,9 @@ class MathTests(unittest.TestCase): def testFloor(self): self.assertRaises(TypeError, math.floor) # These types will be int in py3k. - self.assertEquals(float, type(math.floor(1))) - self.assertEquals(float, type(math.floor(1L))) - self.assertEquals(float, type(math.floor(1.0))) + self.assertEqual(float, type(math.floor(1))) + self.assertEqual(float, type(math.floor(1L))) + self.assertEqual(float, type(math.floor(1.0))) 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) @@ -397,8 +397,8 @@ class MathTests(unittest.TestCase): # 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(object): @@ -429,12 +429,12 @@ class MathTests(unittest.TestCase): 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) @@ -450,8 +450,8 @@ class MathTests(unittest.TestCase): 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])) @requires_IEEE_754 @@ -564,28 +564,28 @@ class MathTests(unittest.TestCase): 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, 10L**5, 10**10, 10L**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): @@ -596,7 +596,7 @@ class MathTests(unittest.TestCase): 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))) @@ -606,19 +606,19 @@ class MathTests(unittest.TestCase): 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))) @@ -634,8 +634,8 @@ class MathTests(unittest.TestCase): 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])) @@ -814,8 +814,8 @@ class MathTests(unittest.TestCase): 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): @@ -823,7 +823,7 @@ class MathTests(unittest.TestCase): 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))) diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py index 8d95a64..c494759 100644 --- a/Lib/test/test_memoryio.py +++ b/Lib/test/test_memoryio.py @@ -23,17 +23,17 @@ class MemorySeekTestMixin: 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") @@ -41,21 +41,21 @@ class MemorySeekTestMixin: 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: @@ -618,7 +618,7 @@ class CBytesIOTest(PyBytesIOTest): self.assertEqual(len(state), 3) bytearray(state[0]) # Check if state[0] supports the buffer interface. self.assertIsInstance(state[1], int) - self.assert_(isinstance(state[2], dict) or state[2] is None) + self.assertTrue(isinstance(state[2], dict) or state[2] is None) memio.close() self.assertRaises(ValueError, memio.__getstate__) @@ -664,7 +664,7 @@ class CStringIOTest(PyStringIOTest): self.assertIsInstance(state[0], unicode) self.assertIsInstance(state[1], str) self.assertIsInstance(state[2], int) - self.assert_(isinstance(state[3], dict) or state[3] is None) + self.assertTrue(isinstance(state[3], dict) or state[3] is None) memio.close() self.assertRaises(ValueError, memio.__getstate__) diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py index 611f57d..61e60fb 100644 --- a/Lib/test/test_memoryview.py +++ b/Lib/test/test_memoryview.py @@ -27,11 +27,11 @@ class AbstractMemoryTests: 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.assertIsInstance(m[0], bytes) - 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 @@ class AbstractMemoryTests: 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: @@ -72,7 +72,7 @@ class AbstractMemoryTests: 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: @@ -115,7 +115,7 @@ class AbstractMemoryTests: 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: @@ -133,14 +133,14 @@ class AbstractMemoryTests: # This calls self.getitem_type() on each separate byte of b"abcdef" expected = b"".join( self.getitem_type(c) for c in b"abcdef") - self.assertEquals(b, expected) + self.assertEqual(b, expected) self.assertIsInstance(b, bytes) def test_tolist(self): for tp in self._types: m = self._view(tp(self._source)) l = m.tolist() - self.assertEquals(l, map(ord, b"abcdef")) + self.assertEqual(l, map(ord, b"abcdef")) def test_compare(self): # memoryviews can compare for equality with other objects @@ -170,27 +170,27 @@ class AbstractMemoryTests: def check_attributes_with_type(self, tp): m = self._view(tp(self._source)) - self.assertEquals(m.format, self.format) + self.assertEqual(m.format, self.format) self.assertIsInstance(m.format, str) - 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.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) # Disabled: unicode uses the old buffer API in 2.x @@ -203,9 +203,9 @@ class AbstractMemoryTests: #oldviewrefcount = sys.getrefcount(m) #s = unicode(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: @@ -269,7 +269,7 @@ class BaseMemoryviewTests: 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" @@ -279,14 +279,14 @@ class BaseMemorySliceTests: 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" @@ -296,7 +296,7 @@ class BaseMemorySliceSliceTests: 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 @@ -323,7 +323,7 @@ class BytesMemoryviewTest(unittest.TestCase, #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_mhlib.py b/Lib/test/test_mhlib.py index f1349bc..996df44 100644 --- a/Lib/test/test_mhlib.py +++ b/Lib/test/test_mhlib.py @@ -148,7 +148,7 @@ class MhlibTests(unittest.TestCase): writeCurMessage('inbox', 2) mh = getMH() - eq = self.assertEquals + eq = self.assertEqual eq(mh.getprofile('Editor'), 'emacs') eq(mh.getprofile('not-set'), None) eq(mh.getpath(), os.path.abspath(_mhpath)) @@ -171,7 +171,7 @@ class MhlibTests(unittest.TestCase): def test_listfolders(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual folders = mh.listfolders() folders.sort() @@ -198,7 +198,7 @@ class MhlibTests(unittest.TestCase): def test_sequence(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual writeCurMessage('wide', 55) f = mh.openfolder('wide') @@ -253,7 +253,7 @@ class MhlibTests(unittest.TestCase): def test_modify(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual mh.makefolder("dummy1") self.assertIn("dummy1", mh.listfolders()) @@ -315,7 +315,7 @@ class MhlibTests(unittest.TestCase): def test_read(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual f = mh.openfolder('inbox') msg = f.openmessage(1) diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py index 8fbc578..90f7d51 100644 --- a/Lib/test/test_minidom.py +++ b/Lib/test/test_minidom.py @@ -748,7 +748,7 @@ class MinidomTest(unittest.TestCase): 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) @@ -948,7 +948,7 @@ class MinidomTest(unittest.TestCase): def testBug0777884(self): doc = parseString("<o>text</o>") text = doc.documentElement.childNodes[0] - self.assertEquals(text.nodeType, Node.TEXT_NODE) + self.assertEqual(text.nodeType, Node.TEXT_NODE) # Should run quietly, doing nothing. text.normalize() doc.unlink() @@ -1226,7 +1226,7 @@ class MinidomTest(unittest.TestCase): 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 a3998e2..b62ed2e 100644 --- a/Lib/test/test_mmap.py +++ b/Lib/test/test_mmap.py @@ -417,7 +417,7 @@ class MmapTests(unittest.TestCase): data = "".join(reversed(data)) L[start:stop:step] = data m[start:stop:step] = data - self.assertEquals(m[:], "".join(L)) + self.assertEqual(m[:], "".join(L)) def make_mmap_file (self, f, halfsize): # Write 2 pages worth of data to the file @@ -512,27 +512,27 @@ class MmapTests(unittest.TestCase): f.close() # Test write_byte() for i in xrange(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, "x") - self.assertEquals(m[:], data) + self.assertEqual(m[:], data) # Test read_byte() m.seek(0) for i in xrange(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), "345") - self.assertEquals(m.tell(), 6) + self.assertEqual(m.read(3), "345") + self.assertEqual(m.tell(), 6) # Test write() m.seek(3) m.write("bar") - self.assertEquals(m.tell(), 6) - self.assertEquals(m[:], "012bar6789") + self.assertEqual(m.tell(), 6) + self.assertEqual(m[:], "012bar6789") m.seek(8) self.assertRaises(ValueError, m.write, "bar") @@ -547,8 +547,8 @@ class MmapTests(unittest.TestCase): 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() @@ -557,8 +557,8 @@ class MmapTests(unittest.TestCase): 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 f5873da..6521c03 100644 --- a/Lib/test/test_multiprocessing.py +++ b/Lib/test/test_multiprocessing.py @@ -183,30 +183,30 @@ class _TestProcess(BaseTestCase): 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.assertNotIn(p, 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.assertIn(p, 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.assertNotIn(p, self.active_children()) @classmethod diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py index c93ef86..6d117d6 100644 --- a/Lib/test/test_opcodes.py +++ b/Lib/test/test_opcodes.py @@ -72,35 +72,35 @@ class OpcodeTest(unittest.TestCase): 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 a4650f4..81a8020 100644 --- a/Lib/test/test_operator.py +++ b/Lib/test/test_operator.py @@ -455,12 +455,12 @@ class OperatorTestCase(unittest.TestCase): 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 bc8bb8a..f86ea01 100644 --- a/Lib/test/test_optparse.py +++ b/Lib/test/test_optparse.py @@ -427,19 +427,19 @@ class TestTypeAliases(BaseTest): 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_new_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") def test_old_type_object(self): self.parser.add_option("-s", type=types.StringType) - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") self.parser.add_option("-x", type=types.IntType) - 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 e83d785..8bb8ce3 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -187,8 +187,8 @@ class StatAttributeTests(unittest.TestCase): 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) # Make sure all the attributes are there members = dir(result) @@ -199,8 +199,8 @@ class StatAttributeTests(unittest.TestCase): 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.assertIn(attr, members) try: @@ -254,13 +254,13 @@ class StatAttributeTests(unittest.TestCase): 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: @@ -295,7 +295,7 @@ class StatAttributeTests(unittest.TestCase): # time stamps in stat, but not in utime. os.utime(test_support.TESTFN, (st.st_atime, int(st.st_mtime-delta))) st2 = os.stat(test_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 @@ -312,7 +312,7 @@ class StatAttributeTests(unittest.TestCase): 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 @@ -346,7 +346,7 @@ class EnvironTests(mapping_tests.BasicTestMappingProtocol): 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") class WalkTests(unittest.TestCase): """Tests for os.walk().""" diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py index e208d53..33b91bd 100644 --- a/Lib/test/test_parser.py +++ b/Lib/test/test_parser.py @@ -19,8 +19,8 @@ class RoundtripLegalSyntaxTestCase(unittest.TestCase): except parser.ParserError, 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) @@ -547,14 +547,14 @@ class CompileTestCase(unittest.TestCase): 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 in globs - self.assertEquals(globs['y'], 5) + self.assertEqual(globs['y'], 5) def test_compile_error(self): st = parser.suite('1 = 3 + 4') diff --git a/Lib/test/test_pep247.py b/Lib/test/test_pep247.py index 7d7425e..423d333 100644 --- a/Lib/test/test_pep247.py +++ b/Lib/test/test_pep247.py @@ -39,24 +39,24 @@ class Pep247Test(unittest.TestCase): obj3.update('string') h2 = obj3.digest() - self.assertEquals(h1, h2) + self.assertEqual(h1, h2) self.assertTrue(hasattr(obj1, 'digest_size')) if not module.digest_size is None: - self.assertEquals(obj1.digest_size, module.digest_size) + self.assertEqual(obj1.digest_size, module.digest_size) - self.assertEquals(obj1.digest_size, len(h1)) + self.assertEqual(obj1.digest_size, len(h1)) obj1.update('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' % ord(byte) - self.assertEquals(hd2, hexdigest) + self.assertEqual(hd2, hexdigest) def test_md5(self): self.check_module(md5) diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py index ad96663..1ae5888 100644 --- a/Lib/test/test_platform.py +++ b/Lib/test/test_platform.py @@ -183,17 +183,17 @@ class PlatformTest(unittest.TestCase): # 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") @@ -211,8 +211,8 @@ class PlatformTest(unittest.TestCase): 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_popen2.py b/Lib/test/test_popen2.py index 715858e..ea41075 100644 --- a/Lib/test/test_popen2.py +++ b/Lib/test/test_popen2.py @@ -63,8 +63,8 @@ class Popen2Test(unittest.TestCase): w.write(teststr) w.close() got = r.read() - self.assertEquals(expected_out, got.strip(), "wrote %r read %r" % - (teststr, got)) + self.assertEqual(expected_out, got.strip(), "wrote %r read %r" % + (teststr, got)) if e is not None: got = e.read() @@ -90,7 +90,7 @@ class Popen2Test(unittest.TestCase): w, r = os.popen2(["echo", self.teststr]) got = r.read() - self.assertEquals(got, self.teststr + "\n") + self.assertEqual(got, self.teststr + "\n") w, r = os.popen2(self.cmd) self.validate_output(self.teststr, self.expected, r, w) @@ -103,7 +103,7 @@ class Popen2Test(unittest.TestCase): w, r, e = os.popen3(["echo", self.teststr]) got = r.read() - self.assertEquals(got, self.teststr + "\n") + self.assertEqual(got, self.teststr + "\n") got = e.read() self.assertFalse(got, "unexpected %r on stderr" % got) @@ -117,7 +117,7 @@ class Popen2Test(unittest.TestCase): w, r = os.popen4(["echo", self.teststr]) got = r.read() - self.assertEquals(got, self.teststr + "\n") + self.assertEqual(got, self.teststr + "\n") w, r = os.popen4(self.cmd) self.validate_output(self.teststr, self.expected, r, w) diff --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py index 1119142..17cdc5b 100644 --- a/Lib/test/test_posix.py +++ b/Lib/test/test_posix.py @@ -103,7 +103,7 @@ class PosixTester(unittest.TestCase): try: posix.initgroups(name, 13) except OSError as e: - self.assertEquals(e.errno, errno.EPERM) + self.assertEqual(e.errno, errno.EPERM) else: self.fail("Expected OSError to be raised by initgroups") diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py index 361a475..1ee67bc 100644 --- a/Lib/test/test_pow.py +++ b/Lib/test/test_pow.py @@ -5,17 +5,17 @@ class PowTest(unittest.TestCase): 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, long: @@ -67,30 +67,30 @@ class PowTest(unittest.TestCase): 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.assertEquals(pow(3L,3L) % 8, pow(3L,3L,8)) - self.assertEquals(pow(3L,3L) % -8, pow(3L,3L,-8)) - self.assertEquals(pow(3L,2) % -2, pow(3L,2,-2)) - self.assertEquals(pow(-3L,3L) % 8, pow(-3L,3L,8)) - self.assertEquals(pow(-3L,3L) % -8, pow(-3L,3L,-8)) - self.assertEquals(pow(5L,2) % -8, pow(5L,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.assertEqual(pow(3L,3L) % 8, pow(3L,3L,8)) + self.assertEqual(pow(3L,3L) % -8, pow(3L,3L,-8)) + self.assertEqual(pow(3L,2) % -2, pow(3L,2,-2)) + self.assertEqual(pow(-3L,3L) % 8, pow(-3L,3L,8)) + self.assertEqual(pow(-3L,3L) % -8, pow(-3L,3L,-8)) + self.assertEqual(pow(5L,2) % -8, pow(5L,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(long(i),j) % k, pow(long(i),j,k) ) @@ -104,7 +104,7 @@ class PowTest(unittest.TestCase): 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 ddf4807..05ab598 100644 --- a/Lib/test/test_pty.py +++ b/Lib/test/test_pty.py @@ -86,7 +86,7 @@ class PtyTest(unittest.TestCase): fcntl.fcntl(master_fd, fcntl.F_SETFL, orig_flags | os.O_NONBLOCK) try: s1 = os.read(master_fd, 1024) - self.assertEquals('', s1) + self.assertEqual('', s1) except OSError, e: if e.errno != errno.EAGAIN: raise @@ -96,14 +96,14 @@ class PtyTest(unittest.TestCase): debug("Writing to slave_fd") os.write(slave_fd, TEST_STRING_1) s1 = os.read(master_fd, 1024) - self.assertEquals('I wish to buy a fish license.\n', - normalize_output(s1)) + self.assertEqual('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('For my pet fish, Eric.\n', normalize_output(s2)) + self.assertEqual('For my pet fish, Eric.\n', normalize_output(s2)) os.close(slave_fd) os.close(master_fd) diff --git a/Lib/test/test_py3kwarn.py b/Lib/test/test_py3kwarn.py index 32c36a9..2afd8a1 100644 --- a/Lib/test/test_py3kwarn.py +++ b/Lib/test/test_py3kwarn.py @@ -397,7 +397,7 @@ class TestStdlibRemovals(unittest.TestCase): reset_module_registry(mod) with check_py3k_warnings() as w: mod.walk("crashers", dumbo, None) - self.assertEquals(str(w.message), msg) + self.assertEqual(str(w.message), msg) def test_reduce_move(self): from operator import add diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py index fda76d4..6aa96d5 100644 --- a/Lib/test/test_pyclbr.py +++ b/Lib/test/test_pyclbr.py @@ -97,7 +97,7 @@ class PyclbrTest(TestCase): self.assertIsInstance(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.assertIsInstance(py_item, (ClassType, type)) if py_item.__module__ != moduleName: @@ -126,7 +126,7 @@ class PyclbrTest(TestCase): 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 68a1451..840a7a8 100644 --- a/Lib/test/test_pyexpat.py +++ b/Lib/test/test_pyexpat.py @@ -22,17 +22,17 @@ class SetAttributeTest(unittest.TestCase): def test_returns_unicode(self): for x, y in self.set_get_pairs: self.parser.returns_unicode = x - self.assertEquals(self.parser.returns_unicode, y) + self.assertEqual(self.parser.returns_unicode, y) 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 = '''\ @@ -140,23 +140,23 @@ class ParseTest(unittest.TestCase): # Verify output op = out.out - 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\\xe1\\xbd\\x80'}") - 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\\xe1\\xbd\\x80'}") + 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): # Try the parse again, this time producing Unicode output @@ -169,23 +169,23 @@ class ParseTest(unittest.TestCase): parser.Parse(data, 1) op = out.out - self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') - self.assertEquals(op[1], "Comment: u' comment data '") - self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") - self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") - self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") - self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") - self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") - self.assertEquals(op[7], "Character data: u'Contents of subelements'") - self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'") - self.assertEquals(op[9], "End of NS decl: u'myns'") - self.assertEquals(op[10], "Start element: u'sub2' {}") - self.assertEquals(op[11], 'Start of CDATA section') - self.assertEquals(op[12], "Character data: u'contents of CDATA section'") - self.assertEquals(op[13], 'End of CDATA section') - self.assertEquals(op[14], "End element: u'sub2'") - self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)") - self.assertEquals(op[16], "End element: u'root'") + self.assertEqual(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') + self.assertEqual(op[1], "Comment: u' comment data '") + self.assertEqual(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") + self.assertEqual(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") + self.assertEqual(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") + self.assertEqual(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") + self.assertEqual(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") + self.assertEqual(op[7], "Character data: u'Contents of subelements'") + self.assertEqual(op[8], "End element: u'http://www.python.org/namespace!subelement'") + self.assertEqual(op[9], "End of NS decl: u'myns'") + self.assertEqual(op[10], "Start element: u'sub2' {}") + self.assertEqual(op[11], 'Start of CDATA section') + self.assertEqual(op[12], "Character data: u'contents of CDATA section'") + self.assertEqual(op[13], 'End of CDATA section') + self.assertEqual(op[14], "End element: u'sub2'") + self.assertEqual(op[15], "External entity ref: (None, u'entity.file', None)") + self.assertEqual(op[16], "End element: u'root'") def test_parse_file(self): # Try parsing a file @@ -199,23 +199,23 @@ class ParseTest(unittest.TestCase): parser.ParseFile(file) op = out.out - self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') - self.assertEquals(op[1], "Comment: u' comment data '") - self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") - self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") - self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") - self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") - self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") - self.assertEquals(op[7], "Character data: u'Contents of subelements'") - self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'") - self.assertEquals(op[9], "End of NS decl: u'myns'") - self.assertEquals(op[10], "Start element: u'sub2' {}") - self.assertEquals(op[11], 'Start of CDATA section') - self.assertEquals(op[12], "Character data: u'contents of CDATA section'") - self.assertEquals(op[13], 'End of CDATA section') - self.assertEquals(op[14], "End element: u'sub2'") - self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)") - self.assertEquals(op[16], "End element: u'root'") + self.assertEqual(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') + self.assertEqual(op[1], "Comment: u' comment data '") + self.assertEqual(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") + self.assertEqual(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") + self.assertEqual(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") + self.assertEqual(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") + self.assertEqual(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") + self.assertEqual(op[7], "Character data: u'Contents of subelements'") + self.assertEqual(op[8], "End element: u'http://www.python.org/namespace!subelement'") + self.assertEqual(op[9], "End of NS decl: u'myns'") + self.assertEqual(op[10], "Start element: u'sub2' {}") + self.assertEqual(op[11], 'Start of CDATA section') + self.assertEqual(op[12], "Character data: u'contents of CDATA section'") + self.assertEqual(op[13], 'End of CDATA section') + self.assertEqual(op[14], "End element: u'sub2'") + self.assertEqual(op[15], "External entity ref: (None, u'entity.file', None)") + self.assertEqual(op[16], "End element: u'root'") class NamespaceSeparatorTest(unittest.TestCase): @@ -231,14 +231,14 @@ class NamespaceSeparatorTest(unittest.TestCase): expat.ParserCreate(namespace_separator=42) self.fail() except TypeError, 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, 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): @@ -264,7 +264,7 @@ class InterningTest(unittest.TestCase): 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) @@ -278,7 +278,7 @@ class BufferTextTest(unittest.TestCase): 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(unicode, expected))) @@ -311,47 +311,47 @@ class BufferTextTest(unittest.TestCase): # 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"], + 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") @@ -359,10 +359,10 @@ class BufferTextTest(unittest.TestCase): 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: @@ -377,9 +377,9 @@ class HandlerExceptionTest(unittest.TestCase): parser.Parse("<a><b><c/></b></a>", 1) self.fail() except RuntimeError, 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: @@ -398,7 +398,7 @@ class PositionTest(unittest.TestCase): 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 @@ -439,10 +439,10 @@ class ChardataBufferTest(unittest.TestCase): """ 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() @@ -466,15 +466,15 @@ class ChardataBufferTest(unittest.TestCase): # 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): @@ -485,27 +485,27 @@ class ChardataBufferTest(unittest.TestCase): 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) @@ -533,14 +533,14 @@ class ChardataBufferTest(unittest.TestCase): 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) @@ -549,14 +549,14 @@ class ChardataBufferTest(unittest.TestCase): 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 //= 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): @@ -566,7 +566,7 @@ class MalformedInputText(unittest.TestCase): 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" @@ -575,7 +575,7 @@ class MalformedInputText(unittest.TestCase): 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 5f5a6ac..0b38e7e 100644 --- a/Lib/test/test_queue.py +++ b/Lib/test/test_queue.py @@ -95,8 +95,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): 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(not q.empty(), "Queue should not be empty") @@ -154,8 +154,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): for i in xrange(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(None) # instruct the threads to close q.join() # verify that you can join twice diff --git a/Lib/test/test_repr.py b/Lib/test/test_repr.py index a8202ee..8b20acd 100644 --- a/Lib/test/test_repr.py +++ b/Lib/test/test_repr.py @@ -22,7 +22,7 @@ def nestedTuple(nesting): 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 @@ class ReprTests(unittest.TestCase): 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 @@ class ReprTests(unittest.TestCase): 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 @@ class ReprTests(unittest.TestCase): "array('i', [1, 2, 3, 4, 5, ...])") def test_numbers(self): - eq = self.assertEquals + eq = self.assertEqual eq(r(123), repr(123)) eq(r(123L), repr(123L)) eq(r(1.0/3), repr(1.0/3)) @@ -111,7 +111,7 @@ class ReprTests(unittest.TestCase): eq(r(n), expected) def test_instance(self): - eq = self.assertEquals + eq = self.assertEqual i1 = ClassWithRepr("a") eq(r(i1), repr(i1)) @@ -141,7 +141,7 @@ class ReprTests(unittest.TestCase): # 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 @@ -149,13 +149,13 @@ class ReprTests(unittest.TestCase): '<built-in method split of str object at 0x')) def test_xrange(self): - eq = self.assertEquals + eq = self.assertEqual eq(repr(xrange(1)), 'xrange(1)') eq(repr(xrange(1, 2)), 'xrange(1, 2)') eq(repr(xrange(1, 2, 3)), 'xrange(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([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") @@ -183,7 +183,7 @@ class ReprTests(unittest.TestCase): 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 @@ -244,7 +244,7 @@ class LongReprTest(unittest.TestCase): del sys.path[0] def test_module(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, self.pkgname + os.extsep + 'py')) from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation eq(repr(areallylongpackageandmodulenametotestreprtruncation), @@ -252,7 +252,7 @@ class LongReprTest(unittest.TestCase): eq(repr(sys), "<module 'sys' (built-in)>") def test_type(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'foo'+os.extsep+'py'), '''\ class foo(object): pass @@ -287,7 +287,7 @@ class baz: "<%s.baz instance at 0x" % baz.__name__)) def test_method(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'qux'+os.extsep+'py'), '''\ class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: def amethod(self): pass diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py index 2280058..adb9305 100644 --- a/Lib/test/test_sax.py +++ b/Lib/test/test_sax.py @@ -29,16 +29,16 @@ class XmlTestBase(unittest.TestCase): 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(attrs.has_key("attr")) - self.assertEquals(attrs.keys(), []) - self.assertEquals(attrs.get("attrs"), None) - self.assertEquals(attrs.get("attrs", 25), 25) - self.assertEquals(attrs.items(), []) - self.assertEquals(attrs.values(), []) + self.assertEqual(attrs.keys(), []) + self.assertEqual(attrs.get("attrs"), None) + self.assertEqual(attrs.get("attrs", 25), 25) + self.assertEqual(attrs.items(), []) + self.assertEqual(attrs.values(), []) def verify_empty_nsattrs(self, attrs): self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr")) @@ -46,33 +46,33 @@ class XmlTestBase(unittest.TestCase): 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(attrs.has_key((ns_uri, "attr"))) - self.assertEquals(attrs.keys(), []) - self.assertEquals(attrs.get((ns_uri, "attr")), None) - self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25) - self.assertEquals(attrs.items(), []) - self.assertEquals(attrs.values(), []) + self.assertEqual(attrs.keys(), []) + self.assertEqual(attrs.get((ns_uri, "attr")), None) + self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25) + self.assertEqual(attrs.items(), []) + self.assertEqual(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(attrs.has_key("attr")) - self.assertEquals(attrs.keys(), ["attr"]) - self.assertEquals(attrs.get("attr"), "val") - self.assertEquals(attrs.get("attr", 25), "val") - self.assertEquals(attrs.items(), [("attr", "val")]) - self.assertEquals(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(attrs.keys(), ["attr"]) + self.assertEqual(attrs.get("attr"), "val") + self.assertEqual(attrs.get("attr", 25), "val") + self.assertEqual(attrs.items(), [("attr", "val")]) + self.assertEqual(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): @@ -102,47 +102,47 @@ class MakeParserTest(unittest.TestCase): 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"), - "\"Includes 'single' and "double" quotes\"") + self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"), + "\"Includes 'single' and "double" quotes\"") # ===== make_parser def test_make_parser(self): @@ -164,7 +164,7 @@ class XmlgenTest(unittest.TestCase): 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() @@ -176,7 +176,7 @@ class XmlgenTest(unittest.TestCase): 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() @@ -188,7 +188,7 @@ class XmlgenTest(unittest.TestCase): 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() @@ -200,7 +200,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), + self.assertEqual(result.getvalue(), start + "<doc><huhei&</doc>") def test_xmlgen_attr_escape(self): @@ -218,7 +218,7 @@ class XmlgenTest(unittest.TestCase): 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>")) @@ -233,7 +233,7 @@ class XmlgenTest(unittest.TestCase): 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() @@ -249,7 +249,7 @@ class XmlgenTest(unittest.TestCase): 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)) @@ -262,7 +262,7 @@ class XmlgenTest(unittest.TestCase): 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() @@ -275,7 +275,7 @@ class XmlgenTest(unittest.TestCase): 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() @@ -288,7 +288,7 @@ class XmlgenTest(unittest.TestCase): 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): @@ -311,11 +311,11 @@ class XmlgenTest(unittest.TestCase): 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 @@ -339,11 +339,11 @@ class XmlgenTest(unittest.TestCase): 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): @@ -360,7 +360,7 @@ class XMLFilterBaseTest(unittest.TestCase): filter.endElement("doc") filter.endDocument() - self.assertEquals(result.getvalue(), start + "<doc>content </doc>") + self.assertEqual(result.getvalue(), start + "<doc>content </doc>") # =========================================================================== # @@ -382,7 +382,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(open(TEST_XMLFILE)) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== DTDHandler support @@ -410,9 +410,9 @@ class ExpatReaderTest(XmlTestBase): 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 @@ -435,8 +435,8 @@ class ExpatReaderTest(XmlTestBase): 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 @@ -488,18 +488,18 @@ class ExpatReaderTest(XmlTestBase): 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(attrs.has_key((ns_uri, "attr"))) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")]) - self.assertEquals(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(attrs.items(), [((ns_uri, "attr"), "val")]) + self.assertEqual(attrs.values(), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs[(ns_uri, "attr")], "val") # ===== InputSource support @@ -511,7 +511,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(TEST_XMLFILE) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_sysid(self): parser = create_parser() @@ -521,7 +521,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(InputSource(TEST_XMLFILE)) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_stream(self): parser = create_parser() @@ -533,7 +533,7 @@ class ExpatReaderTest(XmlTestBase): inpsrc.setByteStream(open(TEST_XMLFILE)) parser.parse(inpsrc) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== IncrementalParser support @@ -547,7 +547,7 @@ class ExpatReaderTest(XmlTestBase): 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() @@ -568,7 +568,7 @@ class ExpatReaderTest(XmlTestBase): parser.feed("</doc>") parser.close() - self.assertEquals(result.getvalue(), start + "<doc>text</doc>") + self.assertEqual(result.getvalue(), start + "<doc>text</doc>") # ===== Locator support @@ -582,9 +582,9 @@ class ExpatReaderTest(XmlTestBase): 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() @@ -593,8 +593,8 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(TEST_XMLFILE) - self.assertEquals(parser.getSystemId(), TEST_XMLFILE) - self.assertEquals(parser.getPublicId(), None) + self.assertEqual(parser.getSystemId(), TEST_XMLFILE) + self.assertEqual(parser.getPublicId(), None) # =========================================================================== @@ -615,7 +615,7 @@ class ErrorReportingTest(unittest.TestCase): parser.parse(source) self.fail() except SAXException, e: - self.assertEquals(e.getSystemId(), name) + self.assertEqual(e.getSystemId(), name) def test_expat_incomplete(self): parser = create_parser() @@ -679,21 +679,21 @@ class XmlReaderTest(XmlTestBase): 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(attrs.has_key((ns_uri, "attr"))) - self.assertEquals(attrs.keys(), [(ns_uri, "attr")]) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")]) - self.assertEquals(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(attrs.keys(), [(ns_uri, "attr")]) + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(attrs.items(), [((ns_uri, "attr"), "val")]) + self.assertEqual(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" @@ -729,7 +729,7 @@ class XmlReaderTest(XmlTestBase): 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 ab9e812..94583e1 100644 --- a/Lib/test/test_scope.py +++ b/Lib/test/test_scope.py @@ -523,7 +523,7 @@ self.assertTrue(X.passed) 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_shutil.py b/Lib/test/test_shutil.py index 9f14fd8..fdc0bc1 100644 --- a/Lib/test/test_shutil.py +++ b/Lib/test/test_shutil.py @@ -431,7 +431,7 @@ class TestShutil(unittest.TestCase): self.assertTrue(os.path.exists(tarball2)) # let's compare both tarballs - self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) + self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2)) # trying an uncompressed one base_name = os.path.join(tmpdir2, 'archive') @@ -525,8 +525,8 @@ class TestShutil(unittest.TestCase): archive = tarfile.open(archive_name) try: for member in archive.getmembers(): - self.assertEquals(member.uid, 0) - self.assertEquals(member.gid, 0) + self.assertEqual(member.uid, 0) + self.assertEqual(member.gid, 0) finally: archive.close() @@ -541,7 +541,7 @@ class TestShutil(unittest.TestCase): make_archive('xxx', 'xxx', root_dir=self.mkdtemp()) except Exception: pass - self.assertEquals(os.getcwd(), current_dir) + self.assertEqual(os.getcwd(), current_dir) finally: unregister_archive_format('xxx') diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py index a703817..8feb145 100644 --- a/Lib/test/test_signal.py +++ b/Lib/test/test_signal.py @@ -203,10 +203,10 @@ class BasicSignalTests(unittest.TestCase): 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 @@ class ItimerTest(unittest.TestCase): "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 @@ class ItimerTest(unittest.TestCase): "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_site.py b/Lib/test/test_site.py index 14d5ca0..4e801e9 100644 --- a/Lib/test/test_site.py +++ b/Lib/test/test_site.py @@ -139,7 +139,7 @@ class HelperFunctionsTests(unittest.TestCase): user_base = site.getuserbase() # the call sets site.USER_BASE - self.assertEquals(site.USER_BASE, user_base) + self.assertEqual(site.USER_BASE, user_base) # let's set PYTHONUSERBASE and see if it uses it site.USER_BASE = None @@ -157,7 +157,7 @@ class HelperFunctionsTests(unittest.TestCase): user_site = site.getusersitepackages() # the call sets USER_BASE *and* USER_SITE - self.assertEquals(site.USER_SITE, user_site) + self.assertEqual(site.USER_SITE, user_site) self.assertTrue(user_site.startswith(site.USER_BASE), user_site) def test_getsitepackages(self): @@ -167,19 +167,19 @@ class HelperFunctionsTests(unittest.TestCase): if sys.platform in ('os2emx', 'riscos'): self.assertEqual(len(dirs), 1) wanted = os.path.join('xoxo', 'Lib', 'site-packages') - self.assertEquals(dirs[0], wanted) + self.assertEqual(dirs[0], wanted) elif os.sep == '/': self.assertEqual(len(dirs), 2) wanted = os.path.join('xoxo', 'lib', 'python' + sys.version[:3], 'site-packages') - self.assertEquals(dirs[0], wanted) + self.assertEqual(dirs[0], wanted) wanted = os.path.join('xoxo', 'lib', 'site-python') - self.assertEquals(dirs[1], wanted) + self.assertEqual(dirs[1], wanted) else: self.assertEqual(len(dirs), 2) - self.assertEquals(dirs[0], 'xoxo') + self.assertEqual(dirs[0], 'xoxo') wanted = os.path.join('xoxo', 'lib', 'site-packages') - self.assertEquals(dirs[1], wanted) + self.assertEqual(dirs[1], wanted) # let's try the specific Apple location if (sys.platform == "darwin" and @@ -189,10 +189,10 @@ class HelperFunctionsTests(unittest.TestCase): self.assertEqual(len(dirs), 4) wanted = os.path.join('~', 'Library', 'Python', sys.version[:3], 'site-packages') - self.assertEquals(dirs[2], os.path.expanduser(wanted)) + self.assertEqual(dirs[2], os.path.expanduser(wanted)) wanted = os.path.join('/Library', 'Python', sys.version[:3], 'site-packages') - self.assertEquals(dirs[3], wanted) + self.assertEqual(dirs[3], wanted) class PthFile(object): """Helper class for handling testing of .pth files""" diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py index b9208e7..3304d6b 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -117,7 +117,7 @@ class SliceTest(unittest.TestCase): x = X() with test_support.check_py3k_warnings(): x[1:2] = 42 - self.assertEquals(tmp, [(1, 2, 42)]) + self.assertEqual(tmp, [(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 a3c1d98..0cf57bd 100644 --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -425,8 +425,8 @@ class GeneralModuleTests(unittest.TestCase): return # No inet_aton, nothing to check # Test that issue1008086 and issue767150 are fixed. # It must return 4 bytes. - self.assertEquals('\x00'*4, socket.inet_aton('0.0.0.0')) - self.assertEquals('\xff'*4, socket.inet_aton('255.255.255.255')) + self.assertEqual('\x00'*4, socket.inet_aton('0.0.0.0')) + self.assertEqual('\xff'*4, socket.inet_aton('255.255.255.255')) def testIPv4toString(self): if not hasattr(socket, 'inet_pton'): @@ -434,16 +434,16 @@ class GeneralModuleTests(unittest.TestCase): from socket import inet_aton as f, inet_pton, AF_INET g = lambda a: inet_pton(AF_INET, a) - self.assertEquals('\x00\x00\x00\x00', f('0.0.0.0')) - self.assertEquals('\xff\x00\xff\x00', f('255.0.255.0')) - self.assertEquals('\xaa\xaa\xaa\xaa', f('170.170.170.170')) - self.assertEquals('\x01\x02\x03\x04', f('1.2.3.4')) - self.assertEquals('\xff\xff\xff\xff', f('255.255.255.255')) + self.assertEqual('\x00\x00\x00\x00', f('0.0.0.0')) + self.assertEqual('\xff\x00\xff\x00', f('255.0.255.0')) + self.assertEqual('\xaa\xaa\xaa\xaa', f('170.170.170.170')) + self.assertEqual('\x01\x02\x03\x04', f('1.2.3.4')) + self.assertEqual('\xff\xff\xff\xff', f('255.255.255.255')) - self.assertEquals('\x00\x00\x00\x00', g('0.0.0.0')) - self.assertEquals('\xff\x00\xff\x00', g('255.0.255.0')) - self.assertEquals('\xaa\xaa\xaa\xaa', g('170.170.170.170')) - self.assertEquals('\xff\xff\xff\xff', g('255.255.255.255')) + self.assertEqual('\x00\x00\x00\x00', g('0.0.0.0')) + self.assertEqual('\xff\x00\xff\x00', g('255.0.255.0')) + self.assertEqual('\xaa\xaa\xaa\xaa', g('170.170.170.170')) + self.assertEqual('\xff\xff\xff\xff', g('255.255.255.255')) def testIPv6toString(self): if not hasattr(socket, 'inet_pton'): @@ -456,10 +456,10 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_pton(AF_INET6, a) - self.assertEquals('\x00' * 16, f('::')) - self.assertEquals('\x00' * 16, f('0::0')) - self.assertEquals('\x00\x01' + '\x00' * 14, f('1::')) - self.assertEquals( + self.assertEqual('\x00' * 16, f('::')) + self.assertEqual('\x00' * 16, f('0::0')) + self.assertEqual('\x00\x01' + '\x00' * 14, f('1::')) + self.assertEqual( '\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 @@ class GeneralModuleTests(unittest.TestCase): 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('\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', f('\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', f('\xff\xff\xff\xff')) - self.assertEquals('1.2.3.4', f('\x01\x02\x03\x04')) + self.assertEqual('1.0.1.0', f('\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', f('\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', f('\xff\xff\xff\xff')) + self.assertEqual('1.2.3.4', f('\x01\x02\x03\x04')) - self.assertEquals('1.0.1.0', g('\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', g('\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', g('\xff\xff\xff\xff')) + self.assertEqual('1.0.1.0', g('\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', g('\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', g('\xff\xff\xff\xff')) def testStringToIPv6(self): if not hasattr(socket, 'inet_ntop'): @@ -490,9 +490,9 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_ntop(AF_INET6, a) - self.assertEquals('::', f('\x00' * 16)) - self.assertEquals('::1', f('\x00' * 15 + '\x01')) - self.assertEquals( + self.assertEqual('::', f('\x00' * 16)) + self.assertEqual('::1', f('\x00' * 15 + '\x01')) + self.assertEqual( 'aef:b01:506:1001:ffff:9997:55:170', f('\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70') ) @@ -1016,8 +1016,8 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : "", ]) fo = socket._fileobject(mock_sock, **kwargs) - self.assertEquals(fo.readline(size), "This is the first line\n") - self.assertEquals(fo.readline(size), "And the second line is here\n") + self.assertEqual(fo.readline(size), "This is the first line\n") + self.assertEqual(fo.readline(size), "And the second line is here\n") def _test_read(self, size=-1, **kwargs): mock_sock = self.MockSocket(recv_funcs=[ @@ -1027,7 +1027,7 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : "", ]) fo = socket._fileobject(mock_sock, **kwargs) - self.assertEquals(fo.read(size), "This is the first line\n" + self.assertEqual(fo.read(size), "This is the first line\n" "And the second line is here\n") def test_default(self): @@ -1052,8 +1052,8 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : "", ]) fo = socket._fileobject(mock_sock, bufsize=0) - self.assertEquals(fo.readline(size), "aa\n") - self.assertEquals(fo.readline(size), "BBbb") + self.assertEqual(fo.readline(size), "aa\n") + self.assertEqual(fo.readline(size), "BBbb") def test_no_buffer(self): self._test_readline_no_buffer() @@ -1192,7 +1192,7 @@ class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest): self.addCleanup(self.cli.close) 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 d4c4f63..4825a4a 100644 --- a/Lib/test/test_socketserver.py +++ b/Lib/test/test_socketserver.py @@ -57,8 +57,8 @@ def simple_subprocess(testcase): 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 @@ class SocketServerTest(unittest.TestCase): 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 @unittest.skipUnless(threading, 'Threading required for this test.') @@ -161,7 +161,7 @@ class SocketServerTest(unittest.TestCase): while data and '\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): @@ -171,7 +171,7 @@ class SocketServerTest(unittest.TestCase): while data and '\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_strop.py b/Lib/test/test_strop.py index 0172957..8ce29ef 100644 --- a/Lib/test/test_strop.py +++ b/Lib/test/test_strop.py @@ -123,7 +123,7 @@ class StropFunctionTestCase(unittest.TestCase): except OverflowError: pass else: - self.assertEquals(len(r), len(a) * 3) + self.assertEqual(len(r), len(a) * 3) @test_support.precisionbigmemtest(size=test_support._2G - 1, memuse=1) def test_stropjoin_huge_tup(self, size): @@ -133,7 +133,7 @@ class StropFunctionTestCase(unittest.TestCase): except OverflowError: pass # acceptable on 32-bit else: - self.assertEquals(len(r), len(a) * 3) + self.assertEqual(len(r), len(a) * 3) transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377' diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py index ff1711c..0cc58c3 100644 --- a/Lib/test/test_structmembers.py +++ b/Lib/test/test_structmembers.py @@ -15,61 +15,61 @@ class ReadWriteTests(unittest.TestCase): 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) @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_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_sys.py b/Lib/test/test_sys.py index 53cdcb2..49f5388 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -120,7 +120,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(0) except SystemExit, exc: - self.assertEquals(exc.code, 0) + self.assertEqual(exc.code, 0) except: self.fail("wrong exception") else: @@ -131,7 +131,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(42) except SystemExit, exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -141,7 +141,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((42,)) except SystemExit, exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -151,7 +151,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit("exit") except SystemExit, exc: - self.assertEquals(exc.code, "exit") + self.assertEqual(exc.code, "exit") except: self.fail("wrong exception") else: @@ -161,7 +161,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((17, 23)) except SystemExit, exc: - self.assertEquals(exc.code, (17, 23)) + self.assertEqual(exc.code, (17, 23)) except: self.fail("wrong exception") else: @@ -213,7 +213,7 @@ class SysModuleTest(unittest.TestCase): 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) diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py index 88722de..142eb2f 100644 --- a/Lib/test/test_sysconfig.py +++ b/Lib/test/test_sysconfig.py @@ -87,7 +87,7 @@ class TestSysConfig(unittest.TestCase): shutil.rmtree(path) def test_get_path_names(self): - self.assertEquals(get_path_names(), sysconfig._SCHEME_KEYS) + self.assertEqual(get_path_names(), sysconfig._SCHEME_KEYS) def test_get_paths(self): scheme = get_paths() @@ -97,7 +97,7 @@ class TestSysConfig(unittest.TestCase): wanted.sort() scheme = scheme.items() scheme.sort() - self.assertEquals(scheme, wanted) + self.assertEqual(scheme, wanted) def test_get_path(self): # xxx make real tests here @@ -116,21 +116,21 @@ class TestSysConfig(unittest.TestCase): sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Intel)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win32') + self.assertEqual(get_platform(), 'win32') # windows XP, amd64 os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Amd64)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-amd64') + self.assertEqual(get_platform(), 'win-amd64') # windows XP, itanium os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Itanium)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-ia64') + self.assertEqual(get_platform(), 'win-ia64') # macbook os.name = 'posix' @@ -149,9 +149,9 @@ class TestSysConfig(unittest.TestCase): maxint = sys.maxint try: sys.maxint = 2147483647 - self.assertEquals(get_platform(), 'macosx-10.3-ppc') + self.assertEqual(get_platform(), 'macosx-10.3-ppc') sys.maxint = 9223372036854775807 - self.assertEquals(get_platform(), 'macosx-10.3-ppc64') + self.assertEqual(get_platform(), 'macosx-10.3-ppc64') finally: sys.maxint = maxint @@ -169,9 +169,9 @@ class TestSysConfig(unittest.TestCase): maxint = sys.maxint try: sys.maxint = 2147483647 - self.assertEquals(get_platform(), 'macosx-10.3-i386') + self.assertEqual(get_platform(), 'macosx-10.3-i386') sys.maxint = 9223372036854775807 - self.assertEquals(get_platform(), 'macosx-10.3-x86_64') + self.assertEqual(get_platform(), 'macosx-10.3-x86_64') finally: sys.maxint = maxint @@ -182,33 +182,33 @@ class TestSysConfig(unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat') + self.assertEqual(get_platform(), 'macosx-10.4-fat') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-intel') + self.assertEqual(get_platform(), 'macosx-10.4-intel') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat3') + self.assertEqual(get_platform(), 'macosx-10.4-fat3') get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-universal') + self.assertEqual(get_platform(), 'macosx-10.4-universal') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat64') + self.assertEqual(get_platform(), 'macosx-10.4-fat64') for arch in ('ppc', 'i386', 'x86_64', 'ppc64'): get_config_vars()['CFLAGS'] = ('-arch %s -isysroot ' @@ -216,7 +216,7 @@ class TestSysConfig(unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3'%(arch,)) - self.assertEquals(get_platform(), 'macosx-10.4-%s'%(arch,)) + self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,)) # linux debian sarge os.name = 'posix' @@ -226,7 +226,7 @@ class TestSysConfig(unittest.TestCase): self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7', '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686')) - self.assertEquals(get_platform(), 'linux-i686') + self.assertEqual(get_platform(), 'linux-i686') # XXX more platforms to tests here @@ -237,7 +237,7 @@ class TestSysConfig(unittest.TestCase): def test_get_scheme_names(self): wanted = ('nt', 'nt_user', 'os2', 'os2_home', 'osx_framework_user', 'posix_home', 'posix_prefix', 'posix_user') - self.assertEquals(get_scheme_names(), wanted) + self.assertEqual(get_scheme_names(), wanted) def test_symlink(self): # Issue 7880 @@ -263,7 +263,7 @@ class TestSysConfig(unittest.TestCase): for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'): global_path = get_path(name, 'posix_prefix') user_path = get_path(name, 'posix_user') - self.assertEquals(user_path, global_path.replace(base, user)) + self.assertEqual(user_path, global_path.replace(base, user)) def test_main(): run_unittest(TestSysConfig) diff --git a/Lib/test/test_tcl.py b/Lib/test/test_tcl.py index 1b3c1cc..e8ba58f 100644 --- a/Lib/test/test_tcl.py +++ b/Lib/test/test_tcl.py @@ -147,7 +147,7 @@ class TclTest(unittest.TestCase): env.unset("TCL_LIBRARY") f = os.popen('%s -c "import Tkinter; print Tkinter"' % (unc_name,)) - self.assert_('Tkinter.py' in f.read()) + self.assertTrue('Tkinter.py' in f.read()) # exit code must be zero self.assertEqual(f.close(), None) diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py index c7da26b..63a54d9 100644 --- a/Lib/test/test_textwrap.py +++ b/Lib/test/test_textwrap.py @@ -29,7 +29,7 @@ class BaseTestCase(unittest.TestCase): 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 @@ class BaseTestCase(unittest.TestCase): 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): @@ -504,7 +504,7 @@ class DedentTestCase(unittest.TestCase): 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. @@ -527,17 +527,17 @@ class DedentTestCase(unittest.TestCase): # 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. @@ -551,27 +551,27 @@ def foo(): 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* @@ -587,17 +587,17 @@ def foo(): # 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_threadedtempfile.py b/Lib/test/test_threadedtempfile.py index 4aeb711..81d9687 100644 --- a/Lib/test/test_threadedtempfile.py +++ b/Lib/test/test_threadedtempfile.py @@ -68,8 +68,8 @@ class ThreadedTempFileTest(unittest.TestCase): 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 a06415d..0ca19b2 100644 --- a/Lib/test/test_threading.py +++ b/Lib/test/test_threading.py @@ -403,17 +403,17 @@ class ThreadTests(BaseTestCase): 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()))) class ThreadJoinOnShutdown(BaseTestCase): diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py index 6683de6..a1029fd 100644 --- a/Lib/test/test_time.py +++ b/Lib/test/test_time.py @@ -94,7 +94,7 @@ class TimeTestCase(unittest.TestCase): # 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_trace.py b/Lib/test/test_trace.py index 3b6c614..7a982f1 100644 --- a/Lib/test/test_trace.py +++ b/Lib/test/test_trace.py @@ -309,7 +309,7 @@ class TestCoverage(unittest.TestCase): 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 811feac..8076be8 100644 --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -185,11 +185,11 @@ class TracebackFormatTests(unittest.TestCase): 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')) diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py index 4904f70..e8d5d8f 100644 --- a/Lib/test/test_unicodedata.py +++ b/Lib/test/test_unicodedata.py @@ -252,7 +252,7 @@ class UnicodeMiscTest(UnicodeDatabaseTest): 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"), u'\U00010346') + self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), u'\U00010346') def test_ucd_510(self): import unicodedata diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py index 7119f55..c6e24d6 100644 --- a/Lib/test/test_urllib.py +++ b/Lib/test/test_urllib.py @@ -112,7 +112,7 @@ class ProxyTests(unittest.TestCase): self.env.set('NO_PROXY', 'localhost') proxies = urllib.getproxies_environment() # getproxies_environment use lowered case truncated (no '_proxy') keys - self.assertEquals('localhost', proxies['no']) + self.assertEqual('localhost', proxies['no']) class urlopen_HttpTests(unittest.TestCase): diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py index 983ffa8..46db6b4 100644 --- a/Lib/test/test_urllib2.py +++ b/Lib/test/test_urllib2.py @@ -45,7 +45,7 @@ class TrivialTests(unittest.TestCase): ('a, b, "c", "d", "e,f", g, h', ['a', 'b', '"c"', '"d"', '"e,f"', 'g', 'h']), ('a="b\\"c", d="e\\,f", g="h\\\\i"', ['a="b"c"', 'd="e,f"', 'g="h\\i"'])] for string, list in tests: - self.assertEquals(urllib2.parse_http_list(string), list) + self.assertEqual(urllib2.parse_http_list(string), list) def test_request_headers_dict(): @@ -872,7 +872,7 @@ class HandlerTests(unittest.TestCase): r = MockResponse(200, "OK", {}, "") newreq = h.http_request(req) self.assertTrue(cj.ach_req is req is newreq) - self.assertEquals(req.get_origin_req_host(), "example.com") + self.assertEqual(req.get_origin_req_host(), "example.com") self.assertTrue(not req.is_unverifiable()) newr = h.http_response(req, r) self.assertTrue(cj.ec_req is req) diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py index 5d8a484..0fda770 100644 --- a/Lib/test/test_urllib2_localnet.py +++ b/Lib/test/test_urllib2_localnet.py @@ -371,8 +371,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/', '/somewhere_else']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/', '/somewhere_else']) finally: self.server.stop() @@ -392,8 +392,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/weeble']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/weeble']) finally: self.server.stop() @@ -407,8 +407,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/bizarre']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/bizarre']) finally: self.server.stop() @@ -421,8 +421,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/bizarre', 'get=with_feeling']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/bizarre', 'get=with_feeling']) finally: self.server.stop() diff --git a/Lib/test/test_userstring.py b/Lib/test/test_userstring.py index 7e5df78..2625985 100755 --- a/Lib/test/test_userstring.py +++ b/Lib/test/test_userstring.py @@ -104,11 +104,11 @@ class MutableStringTest(UserStringTest): data.reverse() L[start:stop:step] = data s[start:stop:step] = "".join(data) - self.assertEquals(s, "".join(L)) + self.assertEqual(s, "".join(L)) del L[start:stop:step] del s[start:stop:step] - self.assertEquals(s, "".join(L)) + self.assertEqual(s, "".join(L)) def test_immutable(self): s = self.type2test("foobar") diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py index bc8d0b8..1c2c0c2 100644 --- a/Lib/test/test_warnings.py +++ b/Lib/test/test_warnings.py @@ -80,7 +80,7 @@ class FilterTests(object): 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, @@ -102,10 +102,10 @@ class FilterTests(object): for x in xrange(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") @@ -116,10 +116,10 @@ class FilterTests(object): 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, @@ -129,14 +129,14 @@ class FilterTests(object): 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: @@ -157,7 +157,7 @@ class FilterTests(object): 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(). @@ -436,7 +436,7 @@ class _WarningsTests(BaseTest): 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__ = {} @@ -447,7 +447,7 @@ class _WarningsTests(BaseTest): 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 ad4cf42..12ab3ba 100644 --- a/Lib/test/test_winreg.py +++ b/Lib/test/test_winreg.py @@ -88,11 +88,11 @@ class BaseWinregTests(unittest.TestCase): # 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), + 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 @@ -118,8 +118,8 @@ class BaseWinregTests(unittest.TestCase): def _read_test_data(self, root_key, OpenKey=OpenKey): # 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 @@ -134,19 +134,19 @@ class BaseWinregTests(unittest.TestCase): self.assertIn(data, test_data, "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, "sub_key", "Read subkey value wrong") + self.assertEqual(read_val, "sub_key", "Read subkey value wrong") try: EnumKey(key, 1) self.fail("Was able to get a second key when I only have one!") @@ -165,8 +165,8 @@ class BaseWinregTests(unittest.TestCase): 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, "sub_key") @@ -326,8 +326,8 @@ class Win64WinregTests(BaseWinregTests): with OpenKey(HKEY_LOCAL_MACHINE, "Software") as key: # HKLM\Software is redirected but not reflected in all OSes self.assertTrue(QueryReflectionKey(key)) - self.assertEquals(None, EnableReflectionKey(key)) - self.assertEquals(None, DisableReflectionKey(key)) + self.assertEqual(None, EnableReflectionKey(key)) + self.assertEqual(None, DisableReflectionKey(key)) self.assertTrue(QueryReflectionKey(key)) @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection") diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py index a1ec80b..49645183 100644 --- a/Lib/test/test_with.py +++ b/Lib/test/test_with.py @@ -732,10 +732,10 @@ class NestedWith(unittest.TestCase): 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_xmllib.py b/Lib/test/test_xmllib.py index 68b883a..966978a 100644 --- a/Lib/test/test_xmllib.py +++ b/Lib/test/test_xmllib.py @@ -36,9 +36,9 @@ class XMLParserTestCase(unittest.TestCase): h.feed(nsdoc) h.close() # The default namespace applies to elements... - self.assertEquals(h.name, "URI foo") + self.assertEqual(h.name, "URI foo") # but not to attributes - self.assertEquals(h.attr, {'attr':'val'}) + self.assertEqual(h.attr, {'attr':'val'}) def test_main(): diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py index 2a3b2d9..6310c97 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -44,8 +44,8 @@ alist = [{'astring': 'foo@bar.baz.spam', class XMLRPCTestCase(unittest.TestCase): def test_dump_load(self): - self.assertEquals(alist, - xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0]) + self.assertEqual(alist, + xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0]) def test_dump_bare_datetime(self): # This checks that an unwrapped datetime.date object can be handled @@ -55,22 +55,22 @@ class XMLRPCTestCase(unittest.TestCase): dt = datetime.datetime(2005, 02, 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, 02, 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() @@ -98,7 +98,7 @@ class XMLRPCTestCase(unittest.TestCase): 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, (2L**99,)) @@ -141,8 +141,8 @@ class XMLRPCTestCase(unittest.TestCase): value = alist + [None] arg1 = (alist + [None],) strg = xmlrpclib.dumps(arg1, allow_none=True) - self.assertEquals(value, - xmlrpclib.loads(strg)[0][0]) + self.assertEqual(value, + xmlrpclib.loads(strg)[0][0]) self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) def test_default_encoding_issues(self): @@ -178,14 +178,14 @@ class XMLRPCTestCase(unittest.TestCase): items = d.items() if have_unicode: - self.assertEquals(s, u"abc \x95") + self.assertEqual(s, u"abc \x95") self.assertIsInstance(s, unicode) - self.assertEquals(items, [(u"def \x96", u"ghi \x97")]) + self.assertEqual(items, [(u"def \x96", u"ghi \x97")]) self.assertIsInstance(items[0][0], unicode) self.assertIsInstance(items[0][1], unicode) else: - self.assertEquals(s, "abc \xc2\x95") - self.assertEquals(items, [("def \xc2\x96", "ghi \xc2\x97")]) + self.assertEqual(s, "abc \xc2\x95") + self.assertEqual(items, [("def \xc2\x96", "ghi \xc2\x97")]) class HelperTestCase(unittest.TestCase): @@ -204,8 +204,8 @@ class FaultTestCase(unittest.TestCase): 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) @@ -903,7 +903,7 @@ class CGIHandlerTestCase(unittest.TestCase): 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_xrange.py b/Lib/test/test_xrange.py index 49f4851..e3c799e 100644 --- a/Lib/test/test_xrange.py +++ b/Lib/test/test_xrange.py @@ -101,8 +101,8 @@ class XrangeTest(unittest.TestCase): for proto in range(pickle.HIGHEST_PROTOCOL + 1): for t in testcases: r = xrange(*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_range_iterators(self): # see issue 7298 diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py index 60a1452..5974c8b 100644 --- a/Lib/test/test_zipimport.py +++ b/Lib/test/test_zipimport.py @@ -103,8 +103,8 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): 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) @@ -219,31 +219,31 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): 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) __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) @@ -263,26 +263,26 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): 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) __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) @@ -296,7 +296,7 @@ class UncompressedZipImportTestCase(ImportHooksBaseTestCase): 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.assertIn('zipimporter object', repr(zi)) finally: z.close() |