diff options
| author | Ezio Melotti <ezio.melotti@gmail.com> | 2010-11-21 01:30:29 (GMT) |
|---|---|---|
| committer | Ezio Melotti <ezio.melotti@gmail.com> | 2010-11-21 01:30:29 (GMT) |
| commit | 19f2aeba67b5b4dc4dfd589d02d4a0b0804e22ee (patch) | |
| tree | 596b5a2c45b058ea3e0cdc49cb7539a21410b98d /Lib/test | |
| parent | b65b4937e20be4a2d3311326909c77bbf2e1c4cd (diff) | |
| download | cpython-19f2aeba67b5b4dc4dfd589d02d4a0b0804e22ee.zip cpython-19f2aeba67b5b4dc4dfd589d02d4a0b0804e22ee.tar.gz cpython-19f2aeba67b5b4dc4dfd589d02d4a0b0804e22ee.tar.bz2 | |
Merged revisions 86596 via svnmerge from
svn+ssh://pythondev@svn.python.org/python/branches/py3k
........
r86596 | ezio.melotti | 2010-11-20 21:04:17 +0200 (Sat, 20 Nov 2010) | 1 line
#9424: Replace deprecated assert* methods in the Python test suite.
........
Diffstat (limited to 'Lib/test')
110 files changed, 1922 insertions, 1923 deletions
diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py index 58689cd..6d20f7d 100644 --- a/Lib/test/buffer_tests.py +++ b/Lib/test/buffer_tests.py @@ -15,32 +15,32 @@ 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 03a4d6f..a69653b 100644 --- a/Lib/test/fork_wait.py +++ b/Lib/test/fork_wait.py @@ -38,8 +38,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): @@ -48,7 +48,7 @@ class ForkWait(unittest.TestCase): time.sleep(LONGSLEEP) a = sorted(self.alive.keys()) - self.assertEquals(a, list(range(NUM_THREADS))) + self.assertEqual(a, list(range(NUM_THREADS))) prefork_lives = self.alive.copy() diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py index 12f4e8f..e3a7845 100644 --- a/Lib/test/list_tests.py +++ b/Lib/test/list_tests.py @@ -337,7 +337,7 @@ 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 @@ -482,7 +482,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/outstanding_bugs.py b/Lib/test/outstanding_bugs.py index 9e4784c..0849ee5 100644 --- a/Lib/test/outstanding_bugs.py +++ b/Lib/test/outstanding_bugs.py @@ -35,7 +35,7 @@ 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 = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -47,7 +47,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 = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -58,7 +58,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 = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -66,7 +66,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 = io.TextIOWrapper(io.BytesIO(self.testdata), encoding="ASCII") @@ -76,7 +76,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") diff --git a/Lib/test/pickletester.py b/Lib/test/pickletester.py index 25af97d..06789cd 100644 --- a/Lib/test/pickletester.py +++ b/Lib/test/pickletester.py @@ -564,7 +564,7 @@ class AbstractPickleTests(unittest.TestCase): def test_get(self): self.assertRaises(KeyError, self.loads, b'g0\np0') - self.assertEquals(self.loads(b'((Kdtp0\nh\x00l.))'), [(100,), (100,)]) + self.assertEqual(self.loads(b'((Kdtp0\nh\x00l.))'), [(100,), (100,)]) def test_insecure_strings(self): # XXX Some of these tests are temporarily disabled diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py index 5148d4b..f655c29 100644 --- a/Lib/test/seq_tests.py +++ b/Lib/test/seq_tests.py @@ -131,8 +131,8 @@ 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]) @@ -199,9 +199,9 @@ class CommonTest(unittest.TestCase): def test_contains(self): u = self.type2test([0, 1, 2]) for i in u: - self.assert_(i in u) + self.assertIn(i, u) for i in min(u)-1, max(u)+1: - self.assert_(i not in u) + self.assertNotIn(i, u) self.assertRaises(TypeError, u.__contains__) @@ -213,8 +213,8 @@ class CommonTest(unittest.TestCase): def __eq__(self, other): return True __hash__ = None # Can't meet hash invariant requirements - self.assert_(AllEq() not in self.type2test([])) - self.assert_(AllEq() in self.type2test([1])) + self.assertNotIn(AllEq(), self.type2test([])) + self.assertIn(AllEq(), self.type2test([1])) def test_contains_order(self): # Sequences must test in-order. If a rich comparison has side @@ -227,7 +227,7 @@ class CommonTest(unittest.TestCase): raise DoNotTestEq checkfirst = self.type2test([1, StopCompares()]) - self.assert_(1 in checkfirst) + self.assertIn(1, checkfirst) checklast = self.type2test([StopCompares(), 1]) self.assertRaises(DoNotTestEq, checklast.__contains__, 1) @@ -268,7 +268,7 @@ 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 5f5b291..a813616 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -67,7 +67,7 @@ class BaseTest(unittest.TestCase): else: obj = subtype(obj) realresult = getattr(obj, methodname)(*args) - self.assert_(obj is not realresult) + self.assertIsNot(obj, realresult) # check that obj.method(*args) raises exc def checkraises(self, exc, obj, methodname, *args): @@ -1170,34 +1170,34 @@ class MixinStrUnicodeTest: pass s1 = subclass("abcd") s2 = t().join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertIsNot(s1, s2) + self.assertIs(type(s2), t) s1 = t("abcd") s2 = t().join([s1]) - self.assert_(s1 is s2) + self.assertIs(s1, s2) # Should also test mixed-type join. if t is str: s1 = subclass("abcd") s2 = "".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertIsNot(s1, s2) + self.assertIs(type(s2), t) s1 = t("abcd") s2 = "".join([s1]) - self.assert_(s1 is s2) + self.assertIs(s1, s2) ## elif t is str8: ## s1 = subclass("abcd") ## s2 = "".join([s1]) -## self.assert_(s1 is not s2) -## self.assert_(type(s2) is str) # promotes! +## self.assertIsNot(s1, s2) +## self.assertIs(type(s2), str) # promotes! ## s1 = t("abcd") ## s2 = "".join([s1]) -## self.assert_(s1 is not s2) -## self.assert_(type(s2) is str) # promotes! +## self.assertIsNot(s1, s2) +## self.assertIs(type(s2), str) # promotes! else: self.fail("unexpected type for MixinStrUnicodeTest %r" % t) diff --git a/Lib/test/test_SimpleHTTPServer.py b/Lib/test/test_SimpleHTTPServer.py index 36c2b89..bca9bd6 100644 --- a/Lib/test/test_SimpleHTTPServer.py +++ b/Lib/test/test_SimpleHTTPServer.py @@ -21,17 +21,17 @@ 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 54ac6aa..02942d1 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, @@ -107,7 +107,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, @@ -127,9 +127,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_array.py b/Lib/test/test_array.py index 4cac68b..97cec11 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -601,11 +601,11 @@ 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 01c4ba3..c74a30d 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -137,7 +137,7 @@ class AST_Tests(unittest.TestCase): (eval_tests, eval_results, "eval")): for i, o in zip(input, output): ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST) - self.assertEquals(to_tuple(ast_tree), o) + self.assertEqual(to_tuple(ast_tree), o) self._assertTrueorder(ast_tree, (0, 0)) def test_base_classes(self): @@ -150,20 +150,20 @@ 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() @@ -181,7 +181,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)) def test_invalid_sum(self): pos = dict(lineno=2, col_offset=3) diff --git a/Lib/test/test_asyncore.py b/Lib/test/test_asyncore.py index c82f9b7..fc1d166 100644 --- a/Lib/test/test_asyncore.py +++ b/Lib/test/test_asyncore.py @@ -254,7 +254,7 @@ class DispatcherTests(unittest.TestCase): sys.stderr = stderr lines = fp.getvalue().splitlines() - self.assertEquals(lines, ['log: %s' % l1, 'log: %s' % l2]) + self.assertEqual(lines, ['log: %s' % l1, 'log: %s' % l2]) def test_log_info(self): d = asyncore.dispatcher() @@ -276,7 +276,7 @@ class DispatcherTests(unittest.TestCase): lines = fp.getvalue().splitlines() expected = ['EGGS: %s' % l1, 'info: %s' % l2, 'SPAM: %s' % l3] - self.assertEquals(lines, expected) + self.assertEqual(lines, expected) def test_unhandled(self): d = asyncore.dispatcher() @@ -301,7 +301,7 @@ class DispatcherTests(unittest.TestCase): 'warning: unhandled write event', 'warning: unhandled connect event', 'warning: unhandled accept event'] - self.assertEquals(lines, expected) + self.assertEqual(lines, expected) def test_issue_8594(self): d = asyncore.dispatcher(socket.socket()) diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index e1b6e27..6126667 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -17,7 +17,7 @@ class AugAssignTest(unittest.TestCase): x |= 5 x ^= 1 x /= 2 - self.assertEquals(x, 3.0) + self.assertEqual(x, 3.0) def test_with_unpacking(self): self.assertRaises(SyntaxError, compile, "x, b += 3", "<test>", "exec") @@ -34,7 +34,7 @@ class AugAssignTest(unittest.TestCase): x[0] |= 5 x[0] ^= 1 x[0] /= 2 - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testInDict(self): x = {0: 2} @@ -48,21 +48,21 @@ class AugAssignTest(unittest.TestCase): x[0] |= 5 x[0] ^= 1 x[0] /= 2 - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testSequences(self): x = [1,2] x += [3,4] x *= 2 - self.assertEquals(x, [1, 2, 3, 4, 1, 2, 3, 4]) + self.assertEqual(x, [1, 2, 3, 4, 1, 2, 3, 4]) x = [1, 2, 3] y = x x[1:2] *= 2 y[1:2] += [1] - self.assertEquals(x, [1, 2, 1, 2, 3]) + self.assertEqual(x, [1, 2, 1, 2, 3]) self.assertTrue(x is y) def testCustomMethods1(self): @@ -90,14 +90,14 @@ class AugAssignTest(unittest.TestCase): self.assertTrue(isinstance(x, aug_test)) self.assertTrue(y is not x) - self.assertEquals(x.val, 11) + self.assertEqual(x.val, 11) x = aug_test2(2) y = x x += 10 self.assertTrue(y is x) - self.assertEquals(x.val, 12) + self.assertEqual(x.val, 12) x = aug_test3(3) y = x @@ -105,7 +105,7 @@ class AugAssignTest(unittest.TestCase): self.assertTrue(isinstance(x, aug_test3)) self.assertTrue(y is not x) - self.assertEquals(x.val, 13) + self.assertEqual(x.val, 13) def testCustomMethods2(test_self): @@ -269,7 +269,7 @@ 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_base64.py b/Lib/test/test_base64.py index 49edf39..33aacd6 100644 --- a/Lib/test/test_base64.py +++ b/Lib/test/test_base64.py @@ -6,7 +6,7 @@ import sys import subprocess - + class LegacyBase64TestCase(unittest.TestCase): def test_encodebytes(self): eq = self.assertEqual @@ -58,7 +58,7 @@ class LegacyBase64TestCase(unittest.TestCase): base64.decode(infp, outfp) self.assertEqual(outfp.getvalue(), b'www.python.org') - + class BaseXYTestCase(unittest.TestCase): def test_b64encode(self): eq = self.assertEqual @@ -209,7 +209,7 @@ class BaseXYTestCase(unittest.TestCase): self.assertTrue(issubclass(binascii.Error, ValueError)) - + class TestMain(unittest.TestCase): def get_output(self, *args, **options): args = (sys.executable, '-m', 'base64') + args @@ -228,20 +228,20 @@ class TestMain(unittest.TestCase): fp.write(b'a\xffb\n') output = self.get_output('-e', support.TESTFN) - self.assertEquals(output.rstrip(), b'Yf9iCg==') + self.assertEqual(output.rstrip(), b'Yf9iCg==') with open(support.TESTFN, 'rb') as fp: output = self.get_output('-e', stdin=fp) - self.assertEquals(output.rstrip(), b'Yf9iCg==') + self.assertEqual(output.rstrip(), b'Yf9iCg==') def test_decode(self): with open(support.TESTFN, 'wb') as fp: fp.write(b'Yf9iCg==') output = self.get_output('-d', support.TESTFN) - self.assertEquals(output.rstrip(), b'a\xffb') + self.assertEqual(output.rstrip(), b'a\xffb') + - def test_main(): support.run_unittest(__name__) diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index 030ada5..7def22b 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -13,7 +13,7 @@ import functools # doesn't release the old 's' (if it exists) until well after its new # value has been created. Use 'del s' before the create_largestring call. # -# - Do *not* compare large objects using assertEquals or similar. It's a +# - Do *not* compare large objects using assertEqual or similar. It's a # lengthy operation and the errormessage will be utterly useless due to # its size. To make sure whether a result has the right contents, better # to use the strip or count methods, or compare meaningful slices. @@ -48,32 +48,32 @@ class BaseStrTest: SUBSTR = self.from_latin1(' abc def ghi') s = _('-') * size + SUBSTR caps = s.capitalize() - self.assertEquals(caps[-len(SUBSTR):], + self.assertEqual(caps[-len(SUBSTR):], SUBSTR.capitalize()) - self.assertEquals(caps.lstrip(_('-')), SUBSTR) + self.assertEqual(caps.lstrip(_('-')), SUBSTR) @bigmemtest(minsize=_2G + 10, memuse=1) def test_center(self, size): SUBSTR = self.from_latin1(' abc def ghi') s = SUBSTR.center(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2 if len(s) % 2: lpadsize += 1 - self.assertEquals(s[lpadsize:-rpadsize], SUBSTR) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G, memuse=2) def test_count(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = _('.') * size + SUBSTR - self.assertEquals(s.count(_('.')), size) + self.assertEqual(s.count(_('.')), size) s += _('.') - self.assertEquals(s.count(_('.')), size + 1) - self.assertEquals(s.count(_(' ')), 3) - self.assertEquals(s.count(_('i')), 1) - self.assertEquals(s.count(_('j')), 0) + self.assertEqual(s.count(_('.')), size + 1) + self.assertEqual(s.count(_(' ')), 3) + self.assertEqual(s.count(_('i')), 1) + self.assertEqual(s.count(_('j')), 0) @bigmemtest(minsize=_2G, memuse=2) def test_endswith(self, size): @@ -92,13 +92,13 @@ class BaseStrTest: _ = self.from_latin1 s = _('-') * size tabsize = 8 - self.assertEquals(s.expandtabs(), s) + self.assertEqual(s.expandtabs(), s) del s slen, remainder = divmod(size, tabsize) s = _(' \t') * slen s = s.expandtabs(tabsize) - self.assertEquals(len(s), size - remainder) - self.assertEquals(len(s.strip(_(' '))), 0) + self.assertEqual(len(s), size - remainder) + self.assertEqual(len(s.strip(_(' '))), 0) @bigmemtest(minsize=_2G, memuse=2) def test_find(self, size): @@ -106,16 +106,16 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.find(_(' ')), 0) - self.assertEquals(s.find(SUBSTR), 0) - self.assertEquals(s.find(_(' '), sublen), sublen + size) - self.assertEquals(s.find(SUBSTR, len(SUBSTR)), sublen + size) - self.assertEquals(s.find(_('i')), SUBSTR.find(_('i'))) - self.assertEquals(s.find(_('i'), sublen), + self.assertEqual(s.find(_(' ')), 0) + self.assertEqual(s.find(SUBSTR), 0) + self.assertEqual(s.find(_(' '), sublen), sublen + size) + self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size) + self.assertEqual(s.find(_('i')), SUBSTR.find(_('i'))) + self.assertEqual(s.find(_('i'), sublen), sublen + size + SUBSTR.find(_('i'))) - self.assertEquals(s.find(_('i'), size), + self.assertEqual(s.find(_('i'), size), sublen + size + SUBSTR.find(_('i'))) - self.assertEquals(s.find(_('j')), -1) + self.assertEqual(s.find(_('j')), -1) @bigmemtest(minsize=_2G, memuse=2) def test_index(self, size): @@ -123,14 +123,14 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.index(_(' ')), 0) - self.assertEquals(s.index(SUBSTR), 0) - self.assertEquals(s.index(_(' '), sublen), sublen + size) - self.assertEquals(s.index(SUBSTR, sublen), sublen + size) - self.assertEquals(s.index(_('i')), SUBSTR.index(_('i'))) - self.assertEquals(s.index(_('i'), sublen), + self.assertEqual(s.index(_(' ')), 0) + self.assertEqual(s.index(SUBSTR), 0) + self.assertEqual(s.index(_(' '), sublen), sublen + size) + self.assertEqual(s.index(SUBSTR, sublen), sublen + size) + self.assertEqual(s.index(_('i')), SUBSTR.index(_('i'))) + self.assertEqual(s.index(_('i'), sublen), sublen + size + SUBSTR.index(_('i'))) - self.assertEquals(s.index(_('i'), size), + self.assertEqual(s.index(_('i'), size), sublen + size + SUBSTR.index(_('i'))) self.assertRaises(ValueError, s.index, _('j')) @@ -209,8 +209,8 @@ class BaseStrTest: _ = self.from_latin1 s = _('A') * size x = s.join([_('aaaaa'), _('bbbbb')]) - self.assertEquals(x.count(_('a')), 5) - self.assertEquals(x.count(_('b')), 5) + self.assertEqual(x.count(_('a')), 5) + self.assertEqual(x.count(_('b')), 5) self.assertTrue(x.startswith(_('aaaaaA'))) self.assertTrue(x.endswith(_('Abbbbb'))) @@ -220,27 +220,27 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) self.assertTrue(s.startswith(SUBSTR + _(' '))) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G + 10, memuse=2) def test_lower(self, size): _ = self.from_latin1 s = _('A') * size s = s.lower() - self.assertEquals(len(s), size) - self.assertEquals(s.count(_('a')), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(_('a')), size) @bigmemtest(minsize=_2G + 10, memuse=1) def test_lstrip(self, size): _ = self.from_latin1 SUBSTR = _('abc def ghi') s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.lstrip(), SUBSTR.lstrip()) + self.assertEqual(len(s), size) + self.assertEqual(s.lstrip(), SUBSTR.lstrip()) del s s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.lstrip() @@ -252,12 +252,12 @@ class BaseStrTest: replacement = _('a') s = _(' ') * size s = s.replace(_(' '), replacement) - self.assertEquals(len(s), size) - self.assertEquals(s.count(replacement), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(replacement), size) s = s.replace(replacement, _(' '), size - 4) - self.assertEquals(len(s), size) - self.assertEquals(s.count(replacement), 4) - self.assertEquals(s[-10:], _(' aaaa')) + self.assertEqual(len(s), size) + self.assertEqual(s.count(replacement), 4) + self.assertEqual(s[-10:], _(' aaaa')) @bigmemtest(minsize=_2G, memuse=2) def test_rfind(self, size): @@ -265,15 +265,15 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' '))) - self.assertEquals(s.rfind(SUBSTR), sublen + size) - self.assertEquals(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' '))) - self.assertEquals(s.rfind(SUBSTR, 0, sublen + size), 0) - self.assertEquals(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i'))) - self.assertEquals(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i'))) - self.assertEquals(s.rfind(_('i'), 0, sublen + size), - SUBSTR.rfind(_('i'))) - self.assertEquals(s.rfind(_('j')), -1) + self.assertEqual(s.rfind(_(' ')), sublen + size + SUBSTR.rfind(_(' '))) + self.assertEqual(s.rfind(SUBSTR), sublen + size) + self.assertEqual(s.rfind(_(' '), 0, size), SUBSTR.rfind(_(' '))) + self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0) + self.assertEqual(s.rfind(_('i')), sublen + size + SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('i'), 0, sublen), SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('i'), 0, sublen + size), + SUBSTR.rfind(_('i'))) + self.assertEqual(s.rfind(_('j')), -1) @bigmemtest(minsize=_2G, memuse=2) def test_rindex(self, size): @@ -281,17 +281,17 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') sublen = len(SUBSTR) s = _('').join([SUBSTR, _('-') * size, SUBSTR]) - self.assertEquals(s.rindex(_(' ')), - sublen + size + SUBSTR.rindex(_(' '))) - self.assertEquals(s.rindex(SUBSTR), sublen + size) - self.assertEquals(s.rindex(_(' '), 0, sublen + size - 1), - SUBSTR.rindex(_(' '))) - self.assertEquals(s.rindex(SUBSTR, 0, sublen + size), 0) - self.assertEquals(s.rindex(_('i')), - sublen + size + SUBSTR.rindex(_('i'))) - self.assertEquals(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i'))) - self.assertEquals(s.rindex(_('i'), 0, sublen + size), - SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_(' ')), + sublen + size + SUBSTR.rindex(_(' '))) + self.assertEqual(s.rindex(SUBSTR), sublen + size) + self.assertEqual(s.rindex(_(' '), 0, sublen + size - 1), + SUBSTR.rindex(_(' '))) + self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0) + self.assertEqual(s.rindex(_('i')), + sublen + size + SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_('i'), 0, sublen), SUBSTR.rindex(_('i'))) + self.assertEqual(s.rindex(_('i'), 0, sublen + size), + SUBSTR.rindex(_('i'))) self.assertRaises(ValueError, s.rindex, _('j')) @bigmemtest(minsize=_2G + 10, memuse=1) @@ -300,19 +300,19 @@ class BaseStrTest: SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) self.assertTrue(s.startswith(SUBSTR + _(' '))) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G + 10, memuse=1) def test_rstrip(self, size): _ = self.from_latin1 SUBSTR = _(' abc def ghi') s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.rstrip(), SUBSTR.rstrip()) + self.assertEqual(len(s), size) + self.assertEqual(s.rstrip(), SUBSTR.rstrip()) del s s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) # Type-specific optimization if isinstance(s, (str, bytes)): stripped = s.rstrip() @@ -330,16 +330,16 @@ class BaseStrTest: SUBSTR = _('a') + _(' ') * chunksize s = SUBSTR * chunksize l = s.split() - self.assertEquals(len(l), chunksize) + self.assertEqual(len(l), chunksize) expected = _('a') for item in l: - self.assertEquals(item, expected) + self.assertEqual(item, expected) del l l = s.split(_('a')) - self.assertEquals(len(l), chunksize + 1) + self.assertEqual(len(l), chunksize + 1) expected = _(' ') * chunksize for item in filter(None, l): - self.assertEquals(item, expected) + self.assertEqual(item, expected) # Allocates a string of twice size (and briefly two) and a list of # size. Because of internal affairs, the s.split() call produces a @@ -352,12 +352,12 @@ class BaseStrTest: _ = self.from_latin1 s = _(' a') * size + _(' ') l = s.split() - self.assertEquals(len(l), size) - self.assertEquals(set(l), set([_('a')])) + self.assertEqual(len(l), size) + self.assertEqual(set(l), set([_('a')])) del l l = s.split(_('a')) - self.assertEquals(len(l), size + 1) - self.assertEquals(set(l), set([_(' ')])) + self.assertEqual(len(l), size + 1) + self.assertEqual(set(l), set([_(' ')])) @bigmemtest(minsize=_2G, memuse=2.1) def test_splitlines(self, size): @@ -368,10 +368,10 @@ class BaseStrTest: SUBSTR = _(' ') * chunksize + _('\n') + _(' ') * chunksize + _('\r\n') s = SUBSTR * chunksize l = s.splitlines() - self.assertEquals(len(l), chunksize * 2) + self.assertEqual(len(l), chunksize * 2) expected = _(' ') * chunksize for item in l: - self.assertEquals(item, expected) + self.assertEqual(item, expected) @bigmemtest(minsize=_2G, memuse=2) def test_startswith(self, size): @@ -387,12 +387,12 @@ class BaseStrTest: _ = self.from_latin1 SUBSTR = _(' abc def ghi ') s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) del s s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G, memuse=2) def test_swapcase(self, size): @@ -402,9 +402,9 @@ class BaseStrTest: repeats = size // sublen + 2 s = SUBSTR * repeats s = s.swapcase() - self.assertEquals(len(s), sublen * repeats) - self.assertEquals(s[:sublen * 3], SUBSTR.swapcase() * 3) - self.assertEquals(s[-sublen * 3:], SUBSTR.swapcase() * 3) + self.assertEqual(len(s), sublen * repeats) + self.assertEqual(s[:sublen * 3], SUBSTR.swapcase() * 3) + self.assertEqual(s[-sublen * 3:], SUBSTR.swapcase() * 3) @bigmemtest(minsize=_2G, memuse=2) def test_title(self, size): @@ -431,20 +431,20 @@ class BaseStrTest: repeats = size // sublen + 2 s = SUBSTR * repeats s = s.translate(trans) - self.assertEquals(len(s), repeats * sublen) - self.assertEquals(s[:sublen], SUBSTR.translate(trans)) - self.assertEquals(s[-sublen:], SUBSTR.translate(trans)) - self.assertEquals(s.count(_('.')), 0) - self.assertEquals(s.count(_('!')), repeats * 2) - self.assertEquals(s.count(_('z')), repeats * 3) + self.assertEqual(len(s), repeats * sublen) + self.assertEqual(s[:sublen], SUBSTR.translate(trans)) + self.assertEqual(s[-sublen:], SUBSTR.translate(trans)) + self.assertEqual(s.count(_('.')), 0) + self.assertEqual(s.count(_('!')), repeats * 2) + self.assertEqual(s.count(_('z')), repeats * 3) @bigmemtest(minsize=_2G + 5, memuse=2) def test_upper(self, size): _ = self.from_latin1 s = _('a') * size s = s.upper() - self.assertEquals(len(s), size) - self.assertEquals(s.count(_('A')), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(_('A')), size) @bigmemtest(minsize=_2G + 20, memuse=1) def test_zfill(self, size): @@ -453,8 +453,8 @@ class BaseStrTest: s = SUBSTR.zfill(size) self.assertTrue(s.endswith(_('0') + SUBSTR[1:])) self.assertTrue(s.startswith(_('-0'))) - self.assertEquals(len(s), size) - self.assertEquals(s.count(_('0')), size - len(SUBSTR)) + self.assertEqual(len(s), size) + self.assertEqual(s.count(_('0')), size - len(SUBSTR)) # This test is meaningful even with size < 2G, as long as the # doubled string is > 2G (but it tests more if both are > 2G :) @@ -462,10 +462,10 @@ class BaseStrTest: def test_concat(self, size): _ = self.from_latin1 s = _('.') * size - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) s = s + s - self.assertEquals(len(s), size * 2) - self.assertEquals(s.count(_('.')), size * 2) + self.assertEqual(len(s), size * 2) + self.assertEqual(s.count(_('.')), size * 2) # This test is meaningful even with size < 2G, as long as the # repeated string is > 2G (but it tests more if both are > 2G :) @@ -473,10 +473,10 @@ class BaseStrTest: def test_repeat(self, size): _ = self.from_latin1 s = _('.') * size - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) s = s * 2 - self.assertEquals(len(s), size * 2) - self.assertEquals(s.count(_('.')), size * 2) + self.assertEqual(len(s), size * 2) + self.assertEqual(s.count(_('.')), size * 2) @bigmemtest(minsize=_2G + 20, memuse=2) def test_slice_and_getitem(self, size): @@ -487,26 +487,26 @@ class BaseStrTest: stepsize = len(s) // 100 stepsize = stepsize - (stepsize % sublen) for i in range(0, len(s) - stepsize, stepsize): - self.assertEquals(s[i], SUBSTR[0]) - self.assertEquals(s[i:i + sublen], SUBSTR) - self.assertEquals(s[i:i + sublen:2], SUBSTR[::2]) + self.assertEqual(s[i], SUBSTR[0]) + self.assertEqual(s[i:i + sublen], SUBSTR) + self.assertEqual(s[i:i + sublen:2], SUBSTR[::2]) if i > 0: - self.assertEquals(s[i + sublen - 1:i - 1:-3], - SUBSTR[sublen::-3]) + self.assertEqual(s[i + sublen - 1:i - 1:-3], + SUBSTR[sublen::-3]) # Make sure we do some slicing and indexing near the end of the # string, too. - self.assertEquals(s[len(s) - 1], SUBSTR[-1]) - self.assertEquals(s[-1], SUBSTR[-1]) - self.assertEquals(s[len(s) - 10], SUBSTR[0]) - self.assertEquals(s[-sublen], SUBSTR[0]) - self.assertEquals(s[len(s):], _('')) - self.assertEquals(s[len(s) - 1:], SUBSTR[-1:]) - self.assertEquals(s[-1:], SUBSTR[-1:]) - self.assertEquals(s[len(s) - sublen:], SUBSTR) - self.assertEquals(s[-sublen:], SUBSTR) - self.assertEquals(len(s[:]), len(s)) - self.assertEquals(len(s[:len(s) - 5]), len(s) - 5) - self.assertEquals(len(s[5:-5]), len(s) - 10) + self.assertEqual(s[len(s) - 1], SUBSTR[-1]) + self.assertEqual(s[-1], SUBSTR[-1]) + self.assertEqual(s[len(s) - 10], SUBSTR[0]) + self.assertEqual(s[-sublen], SUBSTR[0]) + self.assertEqual(s[len(s):], _('')) + self.assertEqual(s[len(s) - 1:], SUBSTR[-1:]) + self.assertEqual(s[-1:], SUBSTR[-1:]) + self.assertEqual(s[len(s) - sublen:], SUBSTR) + self.assertEqual(s[-sublen:], SUBSTR) + self.assertEqual(len(s[:]), len(s)) + self.assertEqual(len(s[:len(s) - 5]), len(s) - 5) + self.assertEqual(len(s[5:-5]), len(s) - 10) self.assertRaises(IndexError, operator.getitem, s, len(s)) self.assertRaises(IndexError, operator.getitem, s, len(s) + 1) @@ -565,7 +565,7 @@ class StrTest(unittest.TestCase, BaseStrTest): expectedsize = size s = c * size - self.assertEquals(len(s.encode(enc)), expectedsize) + self.assertEqual(len(s.encode(enc)), expectedsize) def setUp(self): # HACK: adjust memory use of tests inherited from BaseStrTest @@ -632,7 +632,7 @@ class StrTest(unittest.TestCase, BaseStrTest): self.assertEqual(s, sf) del sf sf = '..%s..' % (s,) - self.assertEquals(len(sf), len(s) + 4) + self.assertEqual(len(sf), len(s) + 4) self.assertTrue(sf.startswith('..-')) self.assertTrue(sf.endswith('-..')) del s, sf @@ -642,18 +642,18 @@ class StrTest(unittest.TestCase, BaseStrTest): s = ''.join([edge, '%s', edge]) del edge s = s % '...' - self.assertEquals(len(s), size * 2 + 3) - self.assertEquals(s.count('.'), 3) - self.assertEquals(s.count('-'), size * 2) + self.assertEqual(len(s), size * 2 + 3) + self.assertEqual(s.count('.'), 3) + self.assertEqual(s.count('-'), size * 2) @bigmemtest(minsize=_2G + 10, memuse=character_size * 2) def test_repr_small(self, size): s = '-' * size s = repr(s) - self.assertEquals(len(s), size + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('-'), size) + self.assertEqual(len(s), size + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('-'), size) del s # repr() will create a string four times as large as this 'binary # string', but we don't want to allocate much more than twice @@ -661,21 +661,21 @@ class StrTest(unittest.TestCase, BaseStrTest): size = size // 5 * 2 s = '\x00' * size s = repr(s) - self.assertEquals(len(s), size * 4 + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('\\'), size) - self.assertEquals(s.count('0'), size * 2) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) @bigmemtest(minsize=_2G + 10, memuse=character_size * 5) def test_repr_large(self, size): s = '\x00' * size s = repr(s) - self.assertEquals(len(s), size * 4 + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('\\'), size) - self.assertEquals(s.count('0'), size * 2) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) @bigmemtest(minsize=2**32 / 5, memuse=character_size * 7) def test_unicode_repr(self, size): @@ -706,7 +706,7 @@ class BytesTest(unittest.TestCase, BaseStrTest): @bigmemtest(minsize=_2G + 2, memuse=1 + character_size) def test_decode(self, size): s = self.from_latin1('.') * size - self.assertEquals(len(s.decode('utf-8')), size) + self.assertEqual(len(s.decode('utf-8')), size) class BytearrayTest(unittest.TestCase, BaseStrTest): @@ -717,7 +717,7 @@ class BytearrayTest(unittest.TestCase, BaseStrTest): @bigmemtest(minsize=_2G + 2, memuse=1 + character_size) def test_decode(self, size): s = self.from_latin1('.') * size - self.assertEquals(len(s.decode('utf-8')), size) + self.assertEqual(len(s.decode('utf-8')), size) test_hash = None test_split_large = None @@ -752,9 +752,9 @@ 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): @@ -767,7 +767,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.assertTrue(5 in t) self.assertFalse((1, 2, 3, 4, 5) in t) self.assertFalse(0 in t) @@ -783,27 +783,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): @@ -826,9 +826,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): @@ -836,9 +836,9 @@ class TupleTest(unittest.TestCase): t = tuple(range(size)) count = 0 for item in t: - self.assertEquals(item, count) + self.assertEqual(item, count) count += 1 - self.assertEquals(count, size) + self.assertEqual(count, size) except MemoryError: pass # acceptable, expected on 32-bit @@ -847,10 +847,10 @@ 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): @@ -886,9 +886,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): @@ -901,7 +901,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]) @@ -916,7 +916,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.assertTrue(5 in l) self.assertFalse([1, 2, 3, 4, 5] in l) self.assertFalse(0 in l) @@ -929,66 +929,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): @@ -1001,13 +1001,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) @@ -1022,10 +1022,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): @@ -1041,20 +1041,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 = [object] * size l.extend(l) - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) @@ -1070,9 +1070,9 @@ class ListTest(unittest.TestCase): def test_index(self, size): l = [1, 2, 3, 4, 5] * size size *= 5 - self.assertEquals(l.index(1), 0) - self.assertEquals(l.index(5, size - 5), size - 1) - self.assertEquals(l.index(5, size - 5, size), size - 1) + self.assertEqual(l.index(1), 0) + self.assertEqual(l.index(5, size - 5), size - 1) + self.assertEqual(l.index(5, size - 5, size), size - 1) self.assertRaises(ValueError, l.index, 1, size - 4, size) self.assertRaises(ValueError, l.index, 6) @@ -1082,80 +1082,80 @@ 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 = ["a", "b", "c", "d", "e"] * size size *= 5 - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) item = l.pop() size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, "e") - self.assertEquals(l[-2:], ["c", "d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, "e") + self.assertEqual(l[-2:], ["c", "d"]) item = l.pop(0) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, "a") - self.assertEquals(l[:2], ["b", "c"]) + self.assertEqual(len(l), size) + self.assertEqual(item, "a") + self.assertEqual(l[:2], ["b", "c"]) item = l.pop(size - 2) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, "c") - self.assertEquals(l[-2:], ["b", "d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, "c") + self.assertEqual(l[-2:], ["b", "d"]) @bigmemtest(minsize=_2G + 10, memuse=8) def test_remove(self, size): l = [10] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l.remove(10) size -= 1 - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) # Because of the earlier l.remove(), this append doesn't trigger # a resize. l.append(5) size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-2:], [10, 5]) + self.assertEqual(len(l), size) + self.assertEqual(l[-2:], [10, 5]) l.remove(5) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-2:], [10, 10]) + self.assertEqual(len(l), size) + self.assertEqual(l[-2:], [10, 10]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_reverse(self, size): l = [1, 2, 3, 4, 5] * size l.reverse() - self.assertEquals(len(l), size * 5) - self.assertEquals(l[-5:], [5, 4, 3, 2, 1]) - self.assertEquals(l[:5], [5, 4, 3, 2, 1]) + self.assertEqual(len(l), size * 5) + self.assertEqual(l[-5:], [5, 4, 3, 2, 1]) + self.assertEqual(l[:5], [5, 4, 3, 2, 1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_sort(self, size): l = [1, 2, 3, 4, 5] * size l.sort() - self.assertEquals(len(l), size * 5) - self.assertEquals(l.count(1), size) - self.assertEquals(l[:10], [1] * 10) - self.assertEquals(l[-10:], [5] * 10) + self.assertEqual(len(l), size * 5) + self.assertEqual(l.count(1), size) + self.assertEqual(l[:10], [1] * 10) + self.assertEqual(l[-10:], [5] * 10) def test_main(): support.run_unittest(StrTest, BytesTest, BytearrayTest, diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 645ef9d..420a17f 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -551,15 +551,15 @@ class 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(int): def __hash__(self): return self - self.assertEquals(hash(Z(42)), hash(42)) + self.assertEqual(hash(Z(42)), hash(42)) def test_hex(self): self.assertEqual(hex(16), '0x10') @@ -791,7 +791,7 @@ 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): @@ -800,7 +800,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(): @@ -808,9 +808,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), '0o144') diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index 28ae5ca..8b964ca 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -246,11 +246,11 @@ 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(''), self.type2test()) + self.assertEqual(self.type2test.fromhex(''), self.type2test()) b = bytearray([0x1a, 0x2b, 0x30]) - self.assertEquals(self.type2test.fromhex('1a2B30'), b) - self.assertEquals(self.type2test.fromhex(' 1A 2B 30 '), b) - self.assertEquals(self.type2test.fromhex('0000'), b'\0\0') + self.assertEqual(self.type2test.fromhex('1a2B30'), b) + self.assertEqual(self.type2test.fromhex(' 1A 2B 30 '), b) + self.assertEqual(self.type2test.fromhex('0000'), b'\0\0') self.assertRaises(TypeError, self.type2test.fromhex, b'1B') self.assertRaises(ValueError, self.type2test.fromhex, 'a') self.assertRaises(ValueError, self.type2test.fromhex, 'rt') @@ -609,11 +609,11 @@ 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 @@ -792,25 +792,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 a3d2640..299870c 100644 --- a/Lib/test/test_cfgparser.py +++ b/Lib/test/test_cfgparser.py @@ -463,14 +463,14 @@ class SortedTestCase(RawConfigParserTestCase): "k=v\n") output = io.StringIO() self.cf.write(output) - self.assertEquals(output.getvalue(), - "[a]\n" - "k = v\n\n" - "[b]\n" - "o1 = 4\n" - "o2 = 3\n" - "o3 = 2\n" - "o4 = 1\n\n") + self.assertEqual(output.getvalue(), + "[a]\n" + "k = v\n\n" + "[b]\n" + "o1 = 4\n" + "o2 = 3\n" + "o3 = 2\n" + "o4 = 1\n\n") def test_main(): support.run_unittest( diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py index ef7dfa5..16c6204 100644 --- a/Lib/test/test_cgi.py +++ b/Lib/test/test_cgi.py @@ -220,7 +220,7 @@ 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.'}, @@ -228,7 +228,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 8b79bde..6226587 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(str(b'abc', codecname), 'abc') - self.assertEquals(str(b'xdef', codecname), 'abcdef') - self.assertEquals(str(b'defx', codecname), 'defabc') - self.assertEquals(str(b'dxf', codecname), 'dabcf') - self.assertEquals(str(b'dxfx', codecname), 'dabcfabc') + self.assertEqual(str(b'abc', codecname), 'abc') + self.assertEqual(str(b'xdef', codecname), 'abcdef') + self.assertEqual(str(b'defx', codecname), 'defabc') + self.assertEqual(str(b'dxf', codecname), 'dabcf') + self.assertEqual(str(b'dxfx', codecname), 'dabcfabc') def test_encodex(self): - self.assertEquals('abc'.encode(codecname), b'abc') - self.assertEquals('xdef'.encode(codecname), b'abcdef') - self.assertEquals('defx'.encode(codecname), b'defabc') - self.assertEquals('dxf'.encode(codecname), b'dabcf') - self.assertEquals('dxfx'.encode(codecname), b'dabcfabc') + self.assertEqual('abc'.encode(codecname), b'abc') + self.assertEqual('xdef'.encode(codecname), b'abcdef') + self.assertEqual('defx'.encode(codecname), b'defabc') + self.assertEqual('dxf'.encode(codecname), b'dabcf') + self.assertEqual('dxfx'.encode(codecname), b'dabcfabc') def test_constructory(self): - self.assertEquals(str(b'ydef', codecname), 'def') - self.assertEquals(str(b'defy', codecname), 'def') - self.assertEquals(str(b'dyf', codecname), 'df') - self.assertEquals(str(b'dyfy', codecname), 'df') + self.assertEqual(str(b'ydef', codecname), 'def') + self.assertEqual(str(b'defy', codecname), 'def') + self.assertEqual(str(b'dyf', codecname), 'df') + self.assertEqual(str(b'dyfy', codecname), 'df') def test_maptoundefined(self): self.assertRaises(UnicodeError, str, b'abc\001', codecname) diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py index 552c521..c7003fb 100644 --- a/Lib/test/test_class.py +++ b/Lib/test/test_class.py @@ -436,7 +436,7 @@ 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 @@ -529,17 +529,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)^(-1)) diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py index 6105fc0..c5b1e25 100644 --- a/Lib/test/test_codeccallbacks.py +++ b/Lib/test/test_codeccallbacks.py @@ -186,7 +186,7 @@ class CodecCallbackTest(unittest.TestCase): charmap = dict((ord(c), bytes(2*c.upper(), 'ascii')) for c in "abcdefgh") sin = "abc" sout = b"AABBCC" - self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout) sin = "abcA" self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap) @@ -194,7 +194,7 @@ class CodecCallbackTest(unittest.TestCase): charmap[ord("?")] = b"XYZ" sin = "abcDEF" sout = b"AABBCCXYZXYZXYZ" - self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout) charmap[ord("?")] = "XYZ" # wrong type in mapping self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap) @@ -327,7 +327,7 @@ 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,17 +437,17 @@ 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", "\u3042", 0, 1, "ouch")), ("", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors( UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), ("", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors( UnicodeTranslateError("\u3042", 0, 1, "ouch")), ("", 1) @@ -477,17 +477,17 @@ class CodecCallbackTest(unittest.TestCase): BadObjectUnicodeDecodeError() ) # With the correct exception, "replace" returns an "?" or "\ufffd" replacement - self.assertEquals( + self.assertEqual( codecs.replace_errors( UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), ("?", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors( UnicodeDecodeError("ascii", bytearray(b"\xff"), 0, 1, "ouch")), ("\ufffd", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors( UnicodeTranslateError("\u3042", 0, 1, "ouch")), ("\ufffd", 1) @@ -520,7 +520,7 @@ class CodecCallbackTest(unittest.TestCase): # Use the correct exception cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) s = "".join(chr(c) for c in cs) - self.assertEquals( + self.assertEqual( codecs.xmlcharrefreplace_errors( UnicodeEncodeError("ascii", s, 0, len(s), "ouch") ), @@ -552,52 +552,52 @@ class CodecCallbackTest(unittest.TestCase): UnicodeTranslateError("\u3042", 0, 1, "ouch") ) # Use the correct exception - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\u3042", 0, 1, "ouch")), ("\\u3042", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\x00", 0, 1, "ouch")), ("\\x00", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\xff", 0, 1, "ouch")), ("\\xff", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\u0100", 0, 1, "ouch")), ("\\u0100", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\uffff", 0, 1, "ouch")), ("\\uffff", 1) ) # 1 on UCS-4 builds, 2 on UCS-2 len_wide = len("\U00010000") - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\U00010000", 0, len_wide, "ouch")), ("\\U00010000", len_wide) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\U0010ffff", 0, len_wide, "ouch")), ("\\U0010ffff", len_wide) ) # Lone surrogates (regardless of unicode width) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\ud800", 0, 1, "ouch")), ("\\ud800", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors( UnicodeEncodeError("ascii", "\udfff", 0, 1, "ouch")), ("\\udfff", 1) @@ -630,14 +630,14 @@ 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") ) @@ -713,11 +713,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") # Valid negative position handler.pos = -2 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?><?>") # Negative position out of bounds handler.pos = -3 @@ -725,11 +725,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>0") # Largest valid positive position (one beyond end of input) handler.pos = 2 - self.assertEquals(b"\xff0".decode("ascii", "test.posreturn"), "<?>") + self.assertEqual(b"\xff0".decode("ascii", "test.posreturn"), "<?>") # Invalid positive position handler.pos = 3 @@ -737,7 +737,7 @@ class CodecCallbackTest(unittest.TestCase): # Restart at the "0" handler.pos = 6 - self.assertEquals(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0") + self.assertEqual(b"\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), "<?>0") class D(dict): def __getitem__(self, key): @@ -767,11 +767,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0") # Valid negative position handler.pos = -2 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?><?>") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?><?>") # Negative position out of bounds handler.pos = -3 @@ -779,11 +779,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>0") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>0") # Largest valid positive position (one beyond end of input handler.pos = 2 - self.assertEquals("\xff0".encode("ascii", "test.posreturn"), b"<?>") + self.assertEqual("\xff0".encode("ascii", "test.posreturn"), b"<?>") # Invalid positive position handler.pos = 3 diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py index 5ee2d9f..93cdf91 100644 --- a/Lib/test/test_codecs.py +++ b/Lib/test/test_codecs.py @@ -300,7 +300,7 @@ class UTF32Test(ReadTest): # try to read it back s = io.BytesIO(d) f = reader(s) - self.assertEquals(f.read(), "spamspam") + self.assertEqual(f.read(), "spamspam") def test_badbom(self): s = io.BytesIO(4*b"\xff") @@ -464,7 +464,7 @@ class UTF16Test(ReadTest): # try to read it back s = io.BytesIO(d) f = reader(s) - self.assertEquals(f.read(), "spamspam") + self.assertEqual(f.read(), "spamspam") def test_badbom(self): s = io.BytesIO(b"\xff\xff") @@ -608,10 +608,10 @@ class UTF8Test(ReadTest): b'[?]') def test_surrogatepass_handler(self): - self.assertEquals("abc\ud800def".encode("utf-8", "surrogatepass"), - b"abc\xed\xa0\x80def") - self.assertEquals(b"abc\xed\xa0\x80def".decode("utf-8", "surrogatepass"), - "abc\ud800def") + self.assertEqual("abc\ud800def".encode("utf-8", "surrogatepass"), + b"abc\xed\xa0\x80def") + self.assertEqual(b"abc\xed\xa0\x80def".decode("utf-8", "surrogatepass"), + "abc\ud800def") self.assertTrue(codecs.lookup_error("surrogatepass")) class UTF7Test(ReadTest): @@ -694,7 +694,7 @@ class UTF8SigTest(ReadTest): def test_bug1601501(self): # SF bug #1601501: check that the codec works with a buffer - self.assertEquals(str(b"\xef\xbb\xbf", "utf-8-sig"), "") + self.assertEqual(str(b"\xef\xbb\xbf", "utf-8-sig"), "") def test_bom(self): d = codecs.getincrementaldecoder("utf-8-sig")() @@ -747,7 +747,7 @@ class 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): @@ -874,16 +874,16 @@ 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( + self.assertEqual( str(uni.encode("punycode"), "ascii").lower(), str(puny, "ascii").lower() ) def test_decode(self): for uni, puny in punycode_testcases: - self.assertEquals(uni, puny.decode("punycode")) + self.assertEqual(uni, puny.decode("punycode")) puny = puny.decode("ascii").encode("ascii") - self.assertEquals(uni, puny.decode("punycode")) + self.assertEqual(uni, puny.decode("punycode")) class UnicodeInternalTest(unittest.TestCase): def test_bug1251300(self): @@ -905,7 +905,7 @@ class UnicodeInternalTest(unittest.TestCase): for internal, uni in ok: if sys.byteorder == "little": internal = bytes(reversed(internal)) - self.assertEquals(uni, internal.decode("unicode_internal")) + self.assertEqual(uni, internal.decode("unicode_internal")) for internal in not_ok: if sys.byteorder == "little": internal = bytes(reversed(internal)) @@ -917,10 +917,10 @@ class UnicodeInternalTest(unittest.TestCase): try: b"\x00\x00\x00\x00\x00\x11\x11\x00".decode("unicode_internal") except UnicodeDecodeError as ex: - self.assertEquals("unicode_internal", ex.encoding) - self.assertEquals(b"\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) - self.assertEquals(4, ex.start) - self.assertEquals(8, ex.end) + self.assertEqual("unicode_internal", ex.encoding) + self.assertEqual(b"\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) + self.assertEqual(4, ex.start) + self.assertEqual(8, ex.end) else: self.fail() @@ -932,15 +932,15 @@ class UnicodeInternalTest(unittest.TestCase): ignored = decoder(bytes("%s\x22\x22\x22\x22%s" % (ab[:4], ab[4:]), "ascii"), "UnicodeInternalTest") - self.assertEquals(("ab", 12), ignored) + self.assertEqual(("ab", 12), ignored) def test_encode_length(self): # Issue 3739 encoder = codecs.getencoder("unicode_internal") - self.assertEquals(encoder("a")[1], 1) - self.assertEquals(encoder("\xe9\u0142")[1], 2) + self.assertEqual(encoder("a")[1], 1) + self.assertEqual(encoder("\xe9\u0142")[1], 2) - self.assertEquals(codecs.escape_encode(br'\x00')[1], 4) + self.assertEqual(codecs.escape_encode(br'\x00')[1], 4) # From http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html nameprep_tests = [ @@ -1111,101 +1111,101 @@ class NameprepTest(unittest.TestCase): else: prepped = str(prepped, "utf-8", "surrogatepass") try: - self.assertEquals(nameprep(orig), prepped) + self.assertEqual(nameprep(orig), prepped) except Exception as e: raise support.TestFailed("Test 3.%d: %s" % (pos+1, str(e))) class IDNACodecTest(unittest.TestCase): def test_builtin_decode(self): - self.assertEquals(str(b"python.org", "idna"), "python.org") - self.assertEquals(str(b"python.org.", "idna"), "python.org.") - self.assertEquals(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org") - self.assertEquals(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.") + self.assertEqual(str(b"python.org", "idna"), "python.org") + self.assertEqual(str(b"python.org.", "idna"), "python.org.") + self.assertEqual(str(b"xn--pythn-mua.org", "idna"), "pyth\xf6n.org") + self.assertEqual(str(b"xn--pythn-mua.org.", "idna"), "pyth\xf6n.org.") def test_builtin_encode(self): - self.assertEquals("python.org".encode("idna"), b"python.org") - self.assertEquals("python.org.".encode("idna"), b"python.org.") - self.assertEquals("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org") - self.assertEquals("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.") + self.assertEqual("python.org".encode("idna"), b"python.org") + self.assertEqual("python.org.".encode("idna"), b"python.org.") + self.assertEqual("pyth\xf6n.org".encode("idna"), b"xn--pythn-mua.org") + self.assertEqual("pyth\xf6n.org.".encode("idna"), b"xn--pythn-mua.org.") def test_stream(self): r = codecs.getreader("idna")(io.BytesIO(b"abc")) r.read(3) - self.assertEquals(r.read(), "") + self.assertEqual(r.read(), "") def test_incremental_decode(self): - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"python.org"), "idna")), "python.org" ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"python.org."), "idna")), "python.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"xn--pythn-mua.org."), "idna")), "pyth\xf6n.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode((bytes([c]) for c in b"xn--pythn-mua.org."), "idna")), "pyth\xf6n.org." ) decoder = codecs.getincrementaldecoder("idna")() - self.assertEquals(decoder.decode(b"xn--xam", ), "") - self.assertEquals(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") - self.assertEquals(decoder.decode(b"rg"), "") - self.assertEquals(decoder.decode(b"", True), "org") + self.assertEqual(decoder.decode(b"xn--xam", ), "") + self.assertEqual(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") + self.assertEqual(decoder.decode(b"rg"), "") + self.assertEqual(decoder.decode(b"", True), "org") decoder.reset() - self.assertEquals(decoder.decode(b"xn--xam", ), "") - self.assertEquals(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") - self.assertEquals(decoder.decode(b"rg."), "org.") - self.assertEquals(decoder.decode(b"", True), "") + self.assertEqual(decoder.decode(b"xn--xam", ), "") + self.assertEqual(decoder.decode(b"ple-9ta.o", ), "\xe4xample.") + self.assertEqual(decoder.decode(b"rg."), "org.") + self.assertEqual(decoder.decode(b"", True), "") def test_incremental_encode(self): - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("python.org", "idna")), b"python.org" ) - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("python.org.", "idna")), b"python.org." ) - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("pyth\xf6n.org.", "idna")), b"xn--pythn-mua.org." ) - self.assertEquals( + self.assertEqual( b"".join(codecs.iterencode("pyth\xf6n.org.", "idna")), b"xn--pythn-mua.org." ) encoder = codecs.getincrementalencoder("idna")() - self.assertEquals(encoder.encode("\xe4x"), b"") - self.assertEquals(encoder.encode("ample.org"), b"xn--xample-9ta.") - self.assertEquals(encoder.encode("", True), b"org") + self.assertEqual(encoder.encode("\xe4x"), b"") + self.assertEqual(encoder.encode("ample.org"), b"xn--xample-9ta.") + self.assertEqual(encoder.encode("", True), b"org") encoder.reset() - self.assertEquals(encoder.encode("\xe4x"), b"") - self.assertEquals(encoder.encode("ample.org."), b"xn--xample-9ta.org.") - self.assertEquals(encoder.encode("", True), b"") + self.assertEqual(encoder.encode("\xe4x"), b"") + self.assertEqual(encoder.encode("ample.org."), b"xn--xample-9ta.org.") + self.assertEqual(encoder.encode("", True), b"") class CodecsModuleTest(unittest.TestCase): def test_decode(self): - self.assertEquals(codecs.decode(b'\xe4\xf6\xfc', 'latin-1'), - '\xe4\xf6\xfc') + self.assertEqual(codecs.decode(b'\xe4\xf6\xfc', 'latin-1'), + '\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.decode) - self.assertEquals(codecs.decode(b'abc'), 'abc') + self.assertEqual(codecs.decode(b'abc'), 'abc') self.assertRaises(UnicodeDecodeError, codecs.decode, b'\xff', 'ascii') def test_encode(self): - self.assertEquals(codecs.encode('\xe4\xf6\xfc', 'latin-1'), - b'\xe4\xf6\xfc') + self.assertEqual(codecs.encode('\xe4\xf6\xfc', 'latin-1'), + b'\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.encode) self.assertRaises(LookupError, codecs.encode, "foo", "__spam__") - self.assertEquals(codecs.encode('abc'), b'abc') + self.assertEqual(codecs.encode('abc'), b'abc') self.assertRaises(UnicodeEncodeError, codecs.encode, '\xffff', 'ascii') def test_register(self): @@ -1241,19 +1241,19 @@ class StreamReaderTest(unittest.TestCase): def test_readlines(self): f = self.reader(self.stream) - self.assertEquals(f.readlines(), ['\ud55c\n', '\uae00']) + self.assertEqual(f.readlines(), ['\ud55c\n', '\uae00']) class EncodedFileTest(unittest.TestCase): def test_basic(self): f = io.BytesIO(b'\xed\x95\x9c\n\xea\xb8\x80') ef = codecs.EncodedFile(f, 'utf-16-le', 'utf-8') - self.assertEquals(ef.read(), b'\\\xd5\n\x00\x00\xae') + self.assertEqual(ef.read(), b'\\\xd5\n\x00\x00\xae') f = io.BytesIO() ef = codecs.EncodedFile(f, 'utf-8', 'latin1') ef.write(b'\xc3\xbc') - self.assertEquals(f.getvalue(), b'\xfc') + self.assertEqual(f.getvalue(), b'\xfc') all_unicode_encodings = [ "ascii", @@ -1511,33 +1511,33 @@ class BasicUnicodeTest(unittest.TestCase, MixInCheckStateHandling): class CharmapTest(unittest.TestCase): def test_decode_with_string_map(self): - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "strict", "abc"), ("abc", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "replace", "ab"), ("ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "replace", "ab\ufffe"), ("ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "ignore", "ab"), ("ab", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(b"\x00\x01\x02", "ignore", "ab\ufffe"), ("ab", 3) ) allbytes = bytes(range(256)) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(allbytes, "ignore", ""), ("", len(allbytes)) ) @@ -1546,14 +1546,14 @@ class WithStmtTest(unittest.TestCase): def test_encodedfile(self): f = io.BytesIO(b"\xc3\xbc") with codecs.EncodedFile(f, "latin-1", "utf-8") as ef: - self.assertEquals(ef.read(), b"\xfc") + self.assertEqual(ef.read(), b"\xfc") def test_streamreaderwriter(self): f = io.BytesIO(b"\xc3\xbc") info = codecs.lookup("utf-8") with codecs.StreamReaderWriter(f, info.streamreader, info.streamwriter, 'strict') as srw: - self.assertEquals(srw.read(), "\xfc") + self.assertEqual(srw.read(), "\xfc") class TypesTest(unittest.TestCase): def test_decode_unicode(self): @@ -1580,10 +1580,10 @@ class TypesTest(unittest.TestCase): def test_unicode_escape(self): # Escape-decoding an unicode string is supported ang gives the same # result as decoding the equivalent ASCII bytes string. - self.assertEquals(codecs.unicode_escape_decode(r"\u1234"), ("\u1234", 6)) - self.assertEquals(codecs.unicode_escape_decode(br"\u1234"), ("\u1234", 6)) - self.assertEquals(codecs.raw_unicode_escape_decode(r"\u1234"), ("\u1234", 6)) - self.assertEquals(codecs.raw_unicode_escape_decode(br"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.unicode_escape_decode(r"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.unicode_escape_decode(br"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.raw_unicode_escape_decode(r"\u1234"), ("\u1234", 6)) + self.assertEqual(codecs.raw_unicode_escape_decode(br"\u1234"), ("\u1234", 6)) class SurrogateEscapeTest(unittest.TestCase): @@ -1634,27 +1634,27 @@ 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(support.TESTFN, 'w+', encoding=encoding) as f: f.write(data[0]) - self.assertNotEquals(f.tell(), 0) + self.assertNotEqual(f.tell(), 0) f.seek(0) f.write(data) f.seek(0) - self.assertEquals(f.read(), data) + self.assertEqual(f.read(), data) # (StreamWriter) Check that the BOM is written after a seek(0) with codecs.open(support.TESTFN, 'w+', encoding=encoding) as f: f.writer.write(data[0]) - self.assertNotEquals(f.writer.tell(), 0) + self.assertNotEqual(f.writer.tell(), 0) f.writer.seek(0) f.writer.write(data) f.seek(0) - self.assertEquals(f.read(), data) + self.assertEqual(f.read(), data) # Check that the BOM is not written after a seek() at a position # different than the start @@ -1663,7 +1663,7 @@ 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 @@ -1672,7 +1672,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 ad44121..ffbcd34 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_no_universal_newlines(self): code = compile_command("'\rfoo\r'", symbol='eval') diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index d435330..dc61fa4 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -535,10 +535,10 @@ class TestCollectionABCs(ABCTestCase): # Test issue 9214 mymap = UserDict() mymap['red'] = 5 - self.assert_(isinstance(mymap.keys(), Set)) - self.assert_(isinstance(mymap.keys(), KeysView)) - self.assert_(isinstance(mymap.items(), Set)) - self.assert_(isinstance(mymap.items(), ItemsView)) + self.assertTrue(isinstance(mymap.keys(), Set)) + self.assertTrue(isinstance(mymap.keys(), KeysView)) + self.assertTrue(isinstance(mymap.items(), Set)) + self.assertTrue(isinstance(mymap.items(), ItemsView)) mymap = UserDict() mymap['red'] = 5 @@ -669,9 +669,9 @@ 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 @@ -879,10 +879,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_complex.py b/Lib/test/test_complex.py index 52429ad..5173494 100644 --- a/Lib/test/test_complex.py +++ b/Lib/test/test_complex.py @@ -404,8 +404,8 @@ 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_copyreg.py b/Lib/test/test_copyreg.py index 4fb89d0..bb3651e 100644 --- a/Lib/test/test_copyreg.py +++ b/Lib/test/test_copyreg.py @@ -40,7 +40,7 @@ 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(copyreg._slotnames(WithoutSlots), []) - self.assertEquals(copyreg._slotnames(WithWeakref), []) + self.assertEqual(copyreg._slotnames(WithoutSlots), []) + self.assertEqual(copyreg._slotnames(WithWeakref), []) expected = ['_WithPrivate__spam'] - self.assertEquals(copyreg._slotnames(WithPrivate), expected) - self.assertEquals(copyreg._slotnames(WithSingleString), ['spam']) + self.assertEqual(copyreg._slotnames(WithPrivate), expected) + self.assertEqual(copyreg._slotnames(WithSingleString), ['spam']) expected = ['eggs', 'spam'] expected.sort() result = copyreg._slotnames(WithInherited) result.sort() - self.assertEquals(result, expected) + self.assertEqual(result, expected) def test_main(): diff --git a/Lib/test/test_datetime.py b/Lib/test/test_datetime.py index 5422fdf..d983d6e 100644 --- a/Lib/test/test_datetime.py +++ b/Lib/test/test_datetime.py @@ -1485,8 +1485,8 @@ 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, @@ -1514,7 +1514,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_descr.py b/Lib/test/test_descr.py index 320a7a7..9c26ed3 100644 --- a/Lib/test/test_descr.py +++ b/Lib/test/test_descr.py @@ -4205,11 +4205,11 @@ 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): @@ -4236,7 +4236,7 @@ class DictProxyTests(unittest.TestCase): # Testing dict-proxy iterkeys... keys = [ key for key in self.C.__dict__.keys() ] keys.sort() - self.assertEquals(keys, ['__dict__', '__doc__', '__module__', + self.assertEqual(keys, ['__dict__', '__doc__', '__module__', '__weakref__', 'meth']) def test_iter_values(self): diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py index 1519689..d1b1037 100644 --- a/Lib/test/test_dict.py +++ b/Lib/test/test_dict.py @@ -473,42 +473,42 @@ class DictTest(unittest.TestCase): k2 = {1:1, 2:2, 3:3}.keys() k3 = {4:4}.keys() - self.assertEquals(k1 - k2, set()) - self.assertEquals(k1 - k3, {1,2}) - self.assertEquals(k2 - k1, {3}) - self.assertEquals(k3 - k1, {4}) - self.assertEquals(k1 & k2, {1,2}) - self.assertEquals(k1 & k3, set()) - self.assertEquals(k1 | k2, {1,2,3}) - self.assertEquals(k1 ^ k2, {3}) - self.assertEquals(k1 ^ k3, {1,2,4}) + self.assertEqual(k1 - k2, set()) + self.assertEqual(k1 - k3, {1,2}) + self.assertEqual(k2 - k1, {3}) + self.assertEqual(k3 - k1, {4}) + self.assertEqual(k1 & k2, {1,2}) + self.assertEqual(k1 & k3, set()) + self.assertEqual(k1 | k2, {1,2,3}) + self.assertEqual(k1 ^ k2, {3}) + self.assertEqual(k1 ^ k3, {1,2,4}) def test_dictview_set_operations_on_items(self): k1 = {1:1, 2:2}.items() k2 = {1:1, 2:2, 3:3}.items() k3 = {4:4}.items() - self.assertEquals(k1 - k2, set()) - self.assertEquals(k1 - k3, {(1,1), (2,2)}) - self.assertEquals(k2 - k1, {(3,3)}) - self.assertEquals(k3 - k1, {(4,4)}) - self.assertEquals(k1 & k2, {(1,1), (2,2)}) - self.assertEquals(k1 & k3, set()) - self.assertEquals(k1 | k2, {(1,1), (2,2), (3,3)}) - self.assertEquals(k1 ^ k2, {(3,3)}) - self.assertEquals(k1 ^ k3, {(1,1), (2,2), (4,4)}) + self.assertEqual(k1 - k2, set()) + self.assertEqual(k1 - k3, {(1,1), (2,2)}) + self.assertEqual(k2 - k1, {(3,3)}) + self.assertEqual(k3 - k1, {(4,4)}) + self.assertEqual(k1 & k2, {(1,1), (2,2)}) + self.assertEqual(k1 & k3, set()) + self.assertEqual(k1 | k2, {(1,1), (2,2), (3,3)}) + self.assertEqual(k1 ^ k2, {(3,3)}) + self.assertEqual(k1 ^ k3, {(1,1), (2,2), (4,4)}) def test_dictview_mixed_set_operations(self): # Just a few for .keys() self.assertTrue({1:1}.keys() == {1}) self.assertTrue({1} == {1:1}.keys()) - self.assertEquals({1:1}.keys() | {2}, {1, 2}) - self.assertEquals({2} | {1:1}.keys(), {1, 2}) + self.assertEqual({1:1}.keys() | {2}, {1, 2}) + self.assertEqual({2} | {1:1}.keys(), {1, 2}) # And a few for .items() self.assertTrue({1:1}.items() == {(1,1)}) self.assertTrue({(1,1)} == {1:1}.items()) - self.assertEquals({1:1}.items() | {2}, {(1,1), 2}) - self.assertEquals({2} | {1:1}.items(), {(1,1), 2}) + self.assertEqual({1:1}.items() | {2}, {(1,1), 2}) + self.assertEqual({2} | {1:1}.items(), {(1,1), 2}) def test_missing(self): # Make sure dict doesn't have a __missing__ method diff --git a/Lib/test/test_epoll.py b/Lib/test/test_epoll.py index 847b991..14ac2d5 100644 --- a/Lib/test/test_epoll.py +++ b/Lib/test/test_epoll.py @@ -58,7 +58,7 @@ class TestEPoll(unittest.TestCase): try: client.connect(('127.0.0.1', self.serverSocket.getsockname()[1])) except socket.error as e: - self.assertEquals(e.args[0], errno.EINPROGRESS) + self.assertEqual(e.args[0], errno.EINPROGRESS) else: raise AssertionError("Connect should have raised EINPROGRESS") server, addr = self.serverSocket.accept() @@ -164,7 +164,7 @@ 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() @@ -185,7 +185,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) @@ -195,7 +195,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 41e3d44..5b36186 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -22,8 +22,8 @@ class ExceptionTests(unittest.TestCase): raise exc("spam") except exc as err: buf2 = str(err) - self.assertEquals(buf1, buf2) - self.assertEquals(exc.__name__, excname) + self.assertEqual(buf1, buf2) + self.assertEqual(exc.__name__, excname) def testRaising(self): self.raise_catch(AttributeError, "AttributeError") @@ -155,7 +155,7 @@ class ExceptionTests(unittest.TestCase): except TypeError as err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code - self.assertEquals(co.co_name, "test_capi1") + self.assertEqual(co.co_name, "test_capi1") self.assertTrue(co.co_filename.endswith('test_exceptions.py')) else: self.fail("Expected exception") @@ -167,10 +167,10 @@ class ExceptionTests(unittest.TestCase): except RuntimeError as err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code - self.assertEquals(co.co_name, "__init__") + self.assertEqual(co.co_name, "__init__") self.assertTrue(co.co_filename.endswith('test_exceptions.py')) co2 = tb.tb_frame.f_back.f_code - self.assertEquals(co2.co_name, "test_capi2") + self.assertEqual(co2.co_name, "test_capi2") else: self.fail("Expected exception") @@ -190,10 +190,9 @@ class ExceptionTests(unittest.TestCase): except NameError: pass else: - self.assertEqual(str(WindowsError(1001)), - "1001") + self.assertEqual(str(WindowsError(1001)), "1001") self.assertEqual(str(WindowsError(1001, "message")), - "[Error 1001] message") + "[Error 1001] message") self.assertEqual(WindowsError(1001, "message").errno, 22) self.assertEqual(WindowsError(1001, "message").winerror, 1001) @@ -290,16 +289,16 @@ class ExceptionTests(unittest.TestCase): raise else: # Verify module name - self.assertEquals(type(e).__module__, 'builtins') + self.assertEqual(type(e).__module__, 'builtins') # Verify no ref leaks in Exc_str() s = str(e) for checkArgName in expected: value = getattr(e, checkArgName) - self.assertEquals(repr(value), - repr(expected[checkArgName]), - '%r.%s == %r, expected %r' % ( - e, checkArgName, - value, expected[checkArgName])) + self.assertEqual(repr(value), + repr(expected[checkArgName]), + '%r.%s == %r, expected %r' % ( + e, checkArgName, + value, expected[checkArgName])) # test for pickling support for p in [pickle]: @@ -309,9 +308,9 @@ 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 testWithTraceback(self): try: @@ -386,7 +385,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(): @@ -536,24 +535,24 @@ class ExceptionTests(unittest.TestCase): yield sys.exc_info()[0] yield sys.exc_info()[0] g = yield_raise() - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], None) - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], None) - self.assertEquals(next(g), None) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], None) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], None) + self.assertEqual(next(g), None) # Same test, but inside an exception handler try: raise TypeError("foo") except TypeError: g = yield_raise() - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], TypeError) - self.assertEquals(next(g), KeyError) - self.assertEquals(sys.exc_info()[0], TypeError) - self.assertEquals(next(g), TypeError) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], TypeError) + self.assertEqual(next(g), KeyError) + self.assertEqual(sys.exc_info()[0], TypeError) + self.assertEqual(next(g), TypeError) del g - self.assertEquals(sys.exc_info()[0], TypeError) + self.assertEqual(sys.exc_info()[0], TypeError) def test_generator_finalizing_and_exc_info(self): # See #7173 @@ -581,7 +580,7 @@ class ExceptionTests(unittest.TestCase): raise Exception(MyObject()) except: pass - self.assertEquals(e, (None, None, None)) + self.assertEqual(e, (None, None, None)) def testUnicodeChangeAttributes(self): # See issue 7309. This was a crasher. diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py index bd2d7c0..30c6ed1 100644 --- a/Lib/test/test_file.py +++ b/Lib/test/test_file.py @@ -25,7 +25,7 @@ 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') @@ -44,7 +44,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 @@ -61,7 +61,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 @@ -82,7 +82,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) @@ -119,12 +119,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) @@ -190,7 +190,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_fileio.py b/Lib/test/test_fileio.py index e9281e3..2a8e05d 100644 --- a/Lib/test/test_fileio.py +++ b/Lib/test/test_fileio.py @@ -29,31 +29,31 @@ 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': @@ -67,7 +67,7 @@ class AutoFileTests(unittest.TestCase): a = array('b', b'x'*10) self.f = _FileIO(TESTFN, 'r') n = self.f.readinto(a) - self.assertEquals(array('b', [1, 2]), a[:n]) + self.assertEqual(array('b', [1, 2]), a[:n]) def test_none_args(self): self.f.write(b"hi\nbye\nabc") @@ -82,19 +82,19 @@ class AutoFileTests(unittest.TestCase): self.assertRaises(TypeError, self.f.write, "Hello!") def testRepr(self): - self.assertEquals(repr(self.f), "<_io.FileIO name=%r mode=%r>" + self.assertEqual(repr(self.f), "<_io.FileIO name=%r mode=%r>" % (self.f.name, self.f.mode)) del self.f.name - self.assertEquals(repr(self.f), "<_io.FileIO fd=%r mode=%r>" + self.assertEqual(repr(self.f), "<_io.FileIO fd=%r mode=%r>" % (self.f.fileno(), self.f.mode)) self.f.close() - self.assertEquals(repr(self.f), "<_io.FileIO [closed]>") + self.assertEqual(repr(self.f), "<_io.FileIO [closed]>") def testErrors(self): f = self.f self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) - #self.assertEquals(f.name, TESTFN) + #self.assertEqual(f.name, TESTFN) self.assertRaises(ValueError, f.read, 10) # Open for reading f.close() self.assertTrue(f.closed) @@ -237,22 +237,22 @@ 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": @@ -264,14 +264,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) @@ -305,7 +305,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 bdaf082..fd8436a 100644 --- a/Lib/test/test_float.py +++ b/Lib/test/test_float.py @@ -341,8 +341,8 @@ 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()) class FormatTestCase(unittest.TestCase): def test_format(self): @@ -415,9 +415,9 @@ class FormatTestCase(unittest.TestCase): self.assertEqual(fmt % -float(arg), '-' + rhs) def test_issue5864(self): - self.assertEquals(format(123.456, '.4'), '123.5') - self.assertEquals(format(1234.56, '.4'), '1.235e+03') - self.assertEquals(format(12345.6, '.4'), '1.235e+04') + self.assertEqual(format(123.456, '.4'), '123.5') + self.assertEqual(format(1234.56, '.4'), '1.235e+03') + self.assertEqual(format(12345.6, '.4'), '1.235e+04') class ReprTestCase(unittest.TestCase): def test_repr(self): diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py index fd6588a..17fdb7f 100644 --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -79,16 +79,16 @@ class 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): @@ -99,8 +99,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): @@ -108,25 +108,25 @@ class FractionTest(unittest.TestCase): try: callable(*args, **kwargs) except exc_type as e: - self.assertEquals(message, str(e)) + self.assertEqual(message, str(e)) else: self.fail("%s not raised" % exc_type.__name__) def testInit(self): - self.assertEquals((0, 1), _components(F())) - self.assertEquals((7, 1), _components(F(7))) - self.assertEquals((7, 3), _components(F(F(7, 3)))) + self.assertEqual((0, 1), _components(F())) + self.assertEqual((7, 1), _components(F(7))) + self.assertEqual((7, 3), _components(F(F(7, 3)))) - self.assertEquals((-1, 1), _components(F(-1, 1))) - self.assertEquals((-1, 1), _components(F(1, -1))) - self.assertEquals((1, 1), _components(F(-2, -2))) - self.assertEquals((1, 2), _components(F(5, 10))) - self.assertEquals((7, 15), _components(F(7, 15))) - self.assertEquals((10**23, 1), _components(F(10**23))) + self.assertEqual((-1, 1), _components(F(-1, 1))) + self.assertEqual((-1, 1), _components(F(1, -1))) + self.assertEqual((1, 1), _components(F(-2, -2))) + self.assertEqual((1, 2), _components(F(5, 10))) + self.assertEqual((7, 15), _components(F(7, 15))) + self.assertEqual((10**23, 1), _components(F(10**23))) - self.assertEquals((3, 77), _components(F(F(3, 7), 11))) - self.assertEquals((-9, 5), _components(F(2, F(-10, 9)))) - self.assertEquals((2486, 2485), _components(F(F(22, 7), F(355, 113)))) + self.assertEqual((3, 77), _components(F(F(3, 7), 11))) + self.assertEqual((-9, 5), _components(F(2, F(-10, 9)))) + self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113)))) self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)", F, 12, 0) @@ -139,20 +139,20 @@ class FractionTest(unittest.TestCase): def testFromString(self): - self.assertEquals((5, 1), _components(F("5"))) - self.assertEquals((3, 2), _components(F("3/2"))) - self.assertEquals((3, 2), _components(F(" \n +3/2"))) - self.assertEquals((-3, 2), _components(F("-3/2 "))) - self.assertEquals((13, 2), _components(F(" 013/02 \n "))) - self.assertEquals((16, 5), _components(F(" 3.2 "))) - self.assertEquals((-16, 5), _components(F(" -3.2 "))) - self.assertEquals((-3, 1), _components(F(" -3. "))) - self.assertEquals((3, 5), _components(F(" .6 "))) - self.assertEquals((1, 3125), _components(F("32.e-5"))) - self.assertEquals((1000000, 1), _components(F("1E+06"))) - self.assertEquals((-12300, 1), _components(F("-1.23e4"))) - self.assertEquals((0, 1), _components(F(" .0e+0\t"))) - self.assertEquals((0, 1), _components(F("-0.000e0"))) + self.assertEqual((5, 1), _components(F("5"))) + self.assertEqual((3, 2), _components(F("3/2"))) + self.assertEqual((3, 2), _components(F(" \n +3/2"))) + self.assertEqual((-3, 2), _components(F("-3/2 "))) + self.assertEqual((13, 2), _components(F(" 013/02 \n "))) + self.assertEqual((16, 5), _components(F(" 3.2 "))) + self.assertEqual((-16, 5), _components(F(" -3.2 "))) + self.assertEqual((-3, 1), _components(F(" -3. "))) + self.assertEqual((3, 5), _components(F(" .6 "))) + self.assertEqual((1, 3125), _components(F("32.e-5"))) + self.assertEqual((1000000, 1), _components(F("1E+06"))) + self.assertEqual((-12300, 1), _components(F("-1.23e4"))) + self.assertEqual((0, 1), _components(F(" .0e+0\t"))) + self.assertEqual((0, 1), _components(F("-0.000e0"))) self.assertRaisesMessage( ZeroDivisionError, "Fraction(3, 0)", @@ -194,33 +194,33 @@ 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), + self.assertEqual((bigint, 1), _components(F.from_float(bigint))) + self.assertEqual((0, 1), _components(F.from_float(-0.0))) + self.assertEqual((10, 1), _components(F.from_float(10.0))) + self.assertEqual((-5, 2), _components(F.from_float(-2.5))) + self.assertEqual((99999999999999991611392, 1), _components(F.from_float(1e23))) - self.assertEquals(float(10**23), float(F.from_float(1e23))) - self.assertEquals((3602879701896397, 1125899906842624), + self.assertEqual(float(10**23), float(F.from_float(1e23))) + self.assertEqual((3602879701896397, 1125899906842624), _components(F.from_float(3.2))) - self.assertEquals(3.2, float(F.from_float(3.2))) + self.assertEqual(3.2, float(F.from_float(3.2))) inf = 1e1000 nan = inf - inf @@ -236,13 +236,13 @@ 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.", @@ -278,15 +278,15 @@ class FractionTest(unittest.TestCase): self.assertTypedEquals(-2, round(F(-15, 10))) self.assertTypedEquals(-1, round(F(-7, 10))) - self.assertEquals(False, bool(F(0, 1))) - self.assertEquals(True, bool(F(3, 2))) + self.assertEqual(False, bool(F(0, 1))) + self.assertEqual(True, bool(F(3, 2))) self.assertTypedEquals(0.1, float(F(1, 10))) # Check that __float__ isn't implemented by converting the # numerator and denominator to float before dividing. self.assertRaises(OverflowError, float, int('2'*400+'7')) - self.assertAlmostEquals(2.0/3, - float(F(int('2'*400+'7'), int('3'*400+'1')))) + self.assertAlmostEqual(2.0/3, + float(F(int('2'*400+'7'), int('3'*400+'1')))) self.assertTypedEquals(0.1+0j, complex(F(1,10))) @@ -299,19 +299,19 @@ class FractionTest(unittest.TestCase): def testArithmetic(self): - self.assertEquals(F(1, 2), F(1, 10) + F(2, 5)) - self.assertEquals(F(-3, 10), F(1, 10) - F(2, 5)) - self.assertEquals(F(1, 25), F(1, 10) * F(2, 5)) - self.assertEquals(F(1, 4), F(1, 10) / F(2, 5)) + self.assertEqual(F(1, 2), F(1, 10) + F(2, 5)) + self.assertEqual(F(-3, 10), F(1, 10) - F(2, 5)) + self.assertEqual(F(1, 25), F(1, 10) * F(2, 5)) + self.assertEqual(F(1, 4), F(1, 10) / F(2, 5)) self.assertTypedEquals(2, F(9, 10) // F(2, 5)) self.assertTypedEquals(10**23, F(10**23, 1) // F(1)) - self.assertEquals(F(2, 3), F(-7, 3) % F(3, 2)) - self.assertEquals(F(8, 27), F(2, 3) ** F(3)) - self.assertEquals(F(27, 8), F(2, 3) ** F(-3)) + self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2)) + self.assertEqual(F(8, 27), F(2, 3) ** F(3)) + self.assertEqual(F(27, 8), F(2, 3) ** F(-3)) self.assertTypedEquals(2.0, F(4) ** F(1, 2)) z = pow(F(-1), F(1, 2)) - self.assertAlmostEquals(z.real, 0) - self.assertEquals(z.imag, 1) + self.assertAlmostEqual(z.real, 0) + self.assertEqual(z.imag, 1) def testMixedArithmetic(self): self.assertTypedEquals(F(11, 10), F(1, 10) + 1) @@ -362,8 +362,8 @@ class FractionTest(unittest.TestCase): self.assertTypedEquals(0.1 + 0j, F(1, 10) ** (1.0 + 0j)) self.assertTypedEquals(4 , 2 ** F(2, 1)) z = pow(-1, F(1, 2)) - self.assertAlmostEquals(0, z.real) - self.assertEquals(1, z.imag) + self.assertAlmostEqual(0, z.real) + self.assertEqual(1, z.imag) self.assertTypedEquals(F(1, 4) , 2 ** F(-2, 1)) self.assertTypedEquals(2.0 , 4 ** F(1, 2)) self.assertTypedEquals(0.25, 2.0 ** F(-2, 1)) @@ -375,7 +375,7 @@ 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)) @@ -497,18 +497,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)", + self.assertEqual("Fraction(7, 3)", repr(F(7, 3))) + self.assertEqual("Fraction(6283185307, 2000000000)", repr(F('3.1415926535'))) - self.assertEquals("Fraction(-1, 100000000000000000000)", + self.assertEqual("Fraction(-1, 100000000000000000000)", repr(F(1, -10**20))) - self.assertEquals("7/3", str(F(7, 3))) - self.assertEquals("7", str(F(7, 1))) + self.assertEqual("7/3", str(F(7, 3))) + self.assertEqual("7", str(F(7, 1))) def testHash(self): - self.assertEquals(hash(2.5), hash(F(5, 2))) - self.assertEquals(hash(10**50), hash(F(10**50))) - self.assertNotEquals(hash(float(10**23)), hash(F(10**23))) + self.assertEqual(hash(2.5), hash(F(5, 2))) + self.assertEqual(hash(10**50), hash(F(10**50))) + self.assertNotEqual(hash(float(10**23)), hash(F(10**23))) def testApproximatePi(self): # Algorithm borrowed from @@ -521,7 +521,7 @@ 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 @@ -535,7 +535,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 ab7b52f..d072145 100644 --- a/Lib/test/test_frozen.py +++ b/Lib/test/test_frozen.py @@ -22,7 +22,7 @@ class FrozenTests(unittest.TestCase): self.assertEqual(len(dir(__phello__)), 7, dir(__phello__)) else: self.assertEqual(len(dir(__phello__)), 8, dir(__phello__)) - self.assertEquals(__phello__.__path__, [__phello__.__name__]) + self.assertEqual(__phello__.__path__, [__phello__.__name__]) try: import __phello__.spam diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py index 3ffc1cc..1e88a34 100644 --- a/Lib/test/test_getargs2.py +++ b/Lib/test/test_getargs2.py @@ -239,7 +239,7 @@ 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: @@ -252,25 +252,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) ) @@ -279,14 +279,14 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords(arg1=(1,2)) except TypeError as err: - self.assertEquals(str(err), "Required argument 'arg2' (pos 2) not found") + self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found") else: self.fail('TypeError should have been raised') def test_too_many_args(self): try: getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111) except TypeError as err: - self.assertEquals(str(err), "function takes at most 5 arguments (6 given)") + self.assertEqual(str(err), "function takes at most 5 arguments (6 given)") else: self.fail('TypeError should have been raised') def test_invalid_keyword(self): @@ -294,7 +294,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords((1,2),3,arg5=10,arg666=666) except TypeError as err: - self.assertEquals(str(err), "'arg666' is an invalid keyword argument for this function") + self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function") else: self.fail('TypeError should have been raised') diff --git a/Lib/test/test_getopt.py b/Lib/test/test_getopt.py index f6f9d2e..0f47fcb 100644 --- a/Lib/test/test_getopt.py +++ b/Lib/test/test_getopt.py @@ -176,9 +176,9 @@ 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 adaea18..f92d304 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('*') u2 = glob.glob('./*') - self.assertEquals(set(type(r) for r in u1), uniset) - self.assertEquals(set(type(r) for r in u2), uniset) + self.assertEqual(set(type(r) for r in u1), uniset) + self.assertEqual(set(type(r) for r in u2), uniset) def test_glob_one_directory(self): eq = self.assertSequencesEqual_noorder diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py index b861207..ff8dc93 100644 --- a/Lib/test/test_grammar.py +++ b/Lib/test/test_grammar.py @@ -20,23 +20,23 @@ class TokenTests(unittest.TestCase): # Backslash means line continuation: x = 1 \ + 1 - self.assertEquals(x, 2, 'backslash for line continuation') + self.assertEqual(x, 2, 'backslash for line continuation') # Backslash does not means continuation in comments :\ x = 0 - self.assertEquals(x, 0, 'backslash ending comment') + self.assertEqual(x, 0, 'backslash ending comment') def testPlainIntegers(self): - self.assertEquals(type(000), type(0)) - self.assertEquals(0xff, 255) - self.assertEquals(0o377, 255) - self.assertEquals(2147483647, 0o17777777777) - self.assertEquals(0b1001, 9) + self.assertEqual(type(000), type(0)) + self.assertEqual(0xff, 255) + self.assertEqual(0o377, 255) + self.assertEqual(2147483647, 0o17777777777) + self.assertEqual(0b1001, 9) # "0x" is not a valid literal self.assertRaises(SyntaxError, eval, "0x") from sys import maxsize if maxsize == 2147483647: - self.assertEquals(-2147483647-1, -0o20000000000) + self.assertEqual(-2147483647-1, -0o20000000000) # XXX -2147483648 self.assertTrue(0o37777777777 > 0) self.assertTrue(0xffffffff > 0) @@ -48,7 +48,7 @@ class TokenTests(unittest.TestCase): except OverflowError: self.fail("OverflowError on huge integer literal %r" % s) elif maxsize == 9223372036854775807: - self.assertEquals(-9223372036854775807-1, -0o1000000000000000000000) + self.assertEqual(-9223372036854775807-1, -0o1000000000000000000000) self.assertTrue(0o1777777777777777777777 > 0) self.assertTrue(0xffffffffffffffff > 0) self.assertTrue(0b11111111111111111111111111111111111111111111111111111111111111 > 0) @@ -103,28 +103,28 @@ jumps over the 'lazy' dog. """ y = '\nThe "quick"\nbrown fox\njumps over\nthe \'lazy\' dog.\n' - self.assertEquals(x, y) + self.assertEqual(x, y) y = ''' The "quick" brown fox jumps over the 'lazy' dog. ''' - self.assertEquals(x, y) + self.assertEqual(x, y) y = "\n\ The \"quick\"\n\ brown fox\n\ jumps over\n\ the 'lazy' dog.\n\ " - self.assertEquals(x, y) + self.assertEqual(x, y) y = '\n\ The \"quick\"\n\ brown fox\n\ jumps over\n\ the \'lazy\' dog.\n\ ' - self.assertEquals(x, y) + self.assertEqual(x, y) def testEllipsis(self): x = ... @@ -165,8 +165,8 @@ class GrammarTests(unittest.TestCase): f1(*(), **{}) def f2(one_argument): pass def f3(two, arguments): pass - self.assertEquals(f2.__code__.co_varnames, ('one_argument',)) - self.assertEquals(f3.__code__.co_varnames, ('two', 'arguments')) + self.assertEqual(f2.__code__.co_varnames, ('one_argument',)) + self.assertEqual(f3.__code__.co_varnames, ('two', 'arguments')) def a1(one_arg,): pass def a2(two, args,): pass def v0(*rest): pass @@ -287,37 +287,37 @@ class GrammarTests(unittest.TestCase): # keyword arguments after *arglist def f(*args, **kwargs): return args, kwargs - self.assertEquals(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), + self.assertEqual(f(1, x=2, *[3, 4], y=5), ((1, 3, 4), {'x':2, 'y':5})) self.assertRaises(SyntaxError, eval, "f(1, *(2,3), 4)") self.assertRaises(SyntaxError, eval, "f(1, x=2, *(3,4), x=5)") # argument annotation tests def f(x) -> list: pass - self.assertEquals(f.__annotations__, {'return': list}) + self.assertEqual(f.__annotations__, {'return': list}) def f(x:int): pass - self.assertEquals(f.__annotations__, {'x': int}) + self.assertEqual(f.__annotations__, {'x': int}) def f(*x:str): pass - self.assertEquals(f.__annotations__, {'x': str}) + self.assertEqual(f.__annotations__, {'x': str}) def f(**x:float): pass - self.assertEquals(f.__annotations__, {'x': float}) + self.assertEqual(f.__annotations__, {'x': float}) def f(x, y:1+2): pass - self.assertEquals(f.__annotations__, {'y': 3}) + self.assertEqual(f.__annotations__, {'y': 3}) def f(a, b:1, c:2, d): pass - self.assertEquals(f.__annotations__, {'b': 1, 'c': 2}) + self.assertEqual(f.__annotations__, {'b': 1, 'c': 2}) def f(a, b:1, c:2, d, e:3=4, f=5, *g:6): pass - self.assertEquals(f.__annotations__, - {'b': 1, 'c': 2, 'e': 3, 'g': 6}) + self.assertEqual(f.__annotations__, + {'b': 1, 'c': 2, 'e': 3, 'g': 6}) def f(a, b:1, c:2, d, e:3=4, f=5, *g:6, h:7, i=8, j:9=10, **k:11) -> 12: pass - self.assertEquals(f.__annotations__, - {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9, - 'k': 11, 'return': 12}) + self.assertEqual(f.__annotations__, + {'b': 1, 'c': 2, 'e': 3, 'g': 6, 'h': 7, 'j': 9, + 'k': 11, 'return': 12}) # Check for SF Bug #1697248 - mixing decorators and a return annotation def null(x): return x @null def f(x) -> list: pass - self.assertEquals(f.__annotations__, {'return': list}) + self.assertEqual(f.__annotations__, {'return': list}) # test MAKE_CLOSURE with a variety of oparg's closure = 1 @@ -333,20 +333,20 @@ class GrammarTests(unittest.TestCase): def testLambdef(self): ### lambdef: 'lambda' [varargslist] ':' test l1 = lambda : 0 - self.assertEquals(l1(), 0) + self.assertEqual(l1(), 0) l2 = lambda : a[d] # XXX just testing the expression l3 = lambda : [2 < x for x in [-1, 3, 0]] - self.assertEquals(l3(), [0, 1, 0]) + self.assertEqual(l3(), [0, 1, 0]) l4 = lambda x = lambda y = lambda z=1 : z : y() : x() - self.assertEquals(l4(), 1) + self.assertEqual(l4(), 1) l5 = lambda x, y, z=2: x + y + z - self.assertEquals(l5(1, 2), 5) - self.assertEquals(l5(1, 2, 3), 6) + self.assertEqual(l5(1, 2), 5) + self.assertEqual(l5(1, 2, 3), 6) check_syntax_error(self, "lambda x: x = 2") check_syntax_error(self, "lambda (None,): None") l6 = lambda x, y, *, k=20: x+y+k - self.assertEquals(l6(1,2), 1+2+20) - self.assertEquals(l6(1,2,k=10), 1+2+10) + self.assertEqual(l6(1,2), 1+2+20) + self.assertEqual(l6(1,2,k=10), 1+2+10) ### stmt: simple_stmt | compound_stmt @@ -502,7 +502,7 @@ class GrammarTests(unittest.TestCase): try: assert 0, "msg" except AssertionError as e: - self.assertEquals(e.args[0], "msg") + self.assertEqual(e.args[0], "msg") else: if __debug__: self.fail("AssertionError not raised by assert 0") @@ -536,7 +536,7 @@ class GrammarTests(unittest.TestCase): x = 1 else: x = 2 - self.assertEquals(x, 2) + self.assertEqual(x, 2) def testFor(self): # 'for' exprlist 'in' exprlist ':' suite ['else' ':' suite] @@ -688,7 +688,7 @@ class GrammarTests(unittest.TestCase): d[1,2,3] = 4 L = list(d) L.sort(key=lambda x: x if isinstance(x, tuple) else ()) - self.assertEquals(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') + self.assertEqual(str(L), '[1, (1,), (1, 2), (1, 2, 3)]') def testAtoms(self): ### atom: '(' [testlist] ')' | '[' [testlist] ']' | '{' [dictsetmaker] '}' | NAME | NUMBER | STRING diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py index a4a7e24..b992384 100644 --- a/Lib/test/test_gzip.py +++ b/Lib/test/test_gzip.py @@ -101,7 +101,7 @@ class TestGzip(unittest.TestCase): contents += ztxt if not ztxt: break zgfile.close() - self.assertEquals(contents, b'a'*201) + self.assertEqual(contents, b'a'*201) def test_readline(self): @@ -160,7 +160,7 @@ class TestGzip(unittest.TestCase): f.seek(10, whence=1) y = f.read(10) f.close() - self.assertEquals(y, data1[20:30]) + self.assertEqual(y, data1[20:30]) def test_seek_write(self): # Try seek, write test diff --git a/Lib/test/test_hashlib.py b/Lib/test/test_hashlib.py index 94635e1..dca23cf 100644 --- a/Lib/test/test_hashlib.py +++ b/Lib/test/test_hashlib.py @@ -224,10 +224,10 @@ class HashLibTestCase(unittest.TestCase): m.update(b'1') m.update(b'#' * gil_minsize) m.update(b'1') - self.assertEquals(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21') + self.assertEqual(m.hexdigest(), 'cb1e1a2cbc80be75e19935d621fb9b21') m = hashlib.md5(b'x' * gil_minsize) - self.assertEquals(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958') + self.assertEqual(m.hexdigest(), 'cfb767f225d58469c5de3632a8803958') def test_threaded_hashing(self): if not threading: diff --git a/Lib/test/test_http_cookiejar.py b/Lib/test/test_http_cookiejar.py index d495586..3e85f62 100644 --- a/Lib/test/test_http_cookiejar.py +++ b/Lib/test/test_http_cookiejar.py @@ -20,10 +20,10 @@ class DateTimeTests(unittest.TestCase): def test_time2isoz(self): base = 1019227000 day = 24*3600 - self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z") - self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z") - self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z") - self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z") + self.assertEqual(time2isoz(base), "2002-04-19 14:36:40Z") + self.assertEqual(time2isoz(base+day), "2002-04-20 14:36:40Z") + self.assertEqual(time2isoz(base+2*day), "2002-04-21 14:36:40Z") + self.assertEqual(time2isoz(base+3*day), "2002-04-22 14:36:40Z") az = time2isoz() bz = time2isoz(500000) @@ -35,13 +35,13 @@ class DateTimeTests(unittest.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): # test http2time for supported dates. Test cases with 2 digit year @@ -69,8 +69,8 @@ class DateTimeTests(unittest.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) @@ -107,7 +107,7 @@ class HeaderTests(unittest.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_special_names(self): # names such as 'expires' are not special in first name=value pair @@ -115,13 +115,13 @@ class HeaderTests(unittest.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): joined = join_header_words([[("foo", None), ("bar", "baz")]]) - self.assertEquals(joined, "foo; bar=baz") + self.assertEqual(joined, "foo; bar=baz") - self.assertEquals(join_header_words([[]]), "") + self.assertEqual(join_header_words([[]]), "") def test_split_header_words(self): tests = [ @@ -151,7 +151,7 @@ class HeaderTests(unittest.TestCase): f = io.StringIO() traceback.print_exc(None, f) result = "(error -- traceback follows)\n\n%s" % f.getvalue() - self.assertEquals(result, expect, """ + self.assertEqual(result, expect, """ When parsing: '%s' Expected: '%s' Got: '%s' @@ -183,7 +183,7 @@ 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' @@ -347,11 +347,11 @@ class CookieTests(unittest.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) @@ -362,13 +362,13 @@ class CookieTests(unittest.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, @@ -412,18 +412,18 @@ class CookieTests(unittest.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"] @@ -453,13 +453,13 @@ class CookieTests(unittest.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 @@ -468,19 +468,19 @@ class CookieTests(unittest.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.assertTrue('spam="bar"' in h) # XXX RFC 2965 expiry rules (some apply to V0 too) @@ -533,7 +533,7 @@ class CookieTests(unittest.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): cases = [ @@ -558,31 +558,31 @@ class CookieTests(unittest.TestCase): ("/foo/bar\uabcd", "/foo/bar%EA%AF%8D"), # UTF-8 encoded ] for arg, result in cases: - self.assertEquals(escape_path(arg), result) + self.assertEqual(escape_path(arg), result) def test_request_path(self): # with parameters req = urllib.request.Request( "http://www.example.com/rheum/rhaponticum;" "foo=bar;sing=song?apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), + self.assertEqual(request_path(req), "/rheum/rhaponticum;foo=bar;sing=song") # without parameters req = urllib.request.Request( "http://www.example.com/rheum/rhaponticum?" "apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), "/rheum/rhaponticum") + self.assertEqual(request_path(req), "/rheum/rhaponticum") # missing final slash req = urllib.request.Request("http://www.example.com") - self.assertEquals(request_path(req), "/") + self.assertEqual(request_path(req), "/") def test_request_port(self): req = urllib.request.Request("http://www.acme.com:1234/", headers={"Host": "www.acme.com:4321"}) - self.assertEquals(request_port(req), "1234") + self.assertEqual(request_port(req), "1234") req = urllib.request.Request("http://www.acme.com/", headers={"Host": "www.acme.com:4321"}) - self.assertEquals(request_port(req), DEFAULT_HTTP_PORT) + self.assertEqual(request_port(req), DEFAULT_HTTP_PORT) def test_request_host(self): # this request is illegal (RFC2616, 14.2.3) @@ -590,15 +590,15 @@ class CookieTests(unittest.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 = urllib.request.Request("http://www.acme.com/", headers={"Host": "irrelevant.com"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") # port shouldn't be in request-host req = urllib.request.Request("http://www.acme.com:2345/resource.html", headers={"Host": "www.acme.com:5432"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") def test_is_HDN(self): self.assertTrue(is_HDN("foo.bar.com")) @@ -611,14 +611,14 @@ class CookieTests(unittest.TestCase): self.assertTrue(not is_HDN("foo.")) def test_reach(self): - self.assertEquals(reach("www.acme.com"), ".acme.com") - self.assertEquals(reach("acme.com"), "acme.com") - self.assertEquals(reach("acme.local"), ".local") - self.assertEquals(reach(".local"), ".local") - self.assertEquals(reach(".com"), ".com") - self.assertEquals(reach("."), ".") - self.assertEquals(reach(""), "") - self.assertEquals(reach("192.168.0.1"), "192.168.0.1") + self.assertEqual(reach("www.acme.com"), ".acme.com") + self.assertEqual(reach("acme.com"), "acme.com") + self.assertEqual(reach("acme.local"), ".local") + self.assertEqual(reach(".local"), ".local") + self.assertEqual(reach(".com"), ".com") + self.assertEqual(reach("."), ".") + self.assertEqual(reach(""), "") + self.assertEqual(reach("192.168.0.1"), "192.168.0.1") def test_domain_match(self): self.assertTrue(domain_match("192.168.1.1", "192.168.1.1")) @@ -664,7 +664,7 @@ class CookieTests(unittest.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 @@ -674,11 +674,11 @@ class CookieTests(unittest.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 @@ -688,17 +688,17 @@ class CookieTests(unittest.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 @@ -707,17 +707,17 @@ class CookieTests(unittest.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 @@ -725,8 +725,8 @@ class CookieTests(unittest.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): pol = DefaultCookiePolicy(rfc2965=True) @@ -734,43 +734,43 @@ class CookieTests(unittest.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): c = CookieJar(policy=DefaultCookiePolicy( @@ -781,24 +781,24 @@ class CookieTests(unittest.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 = urllib.request.Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) req = urllib.request.Request("http://www.coyote.com/") res = FakeResponse(headers, "http://www.coyote.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # set a cookie with non-allowed domain... req = urllib.request.Request("http://www.coyote.com/") res = FakeResponse(headers, "http://www.coyote.com/") cookies = c.make_cookies(res, req) c.set_cookie(cookies[0]) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) self.assertTrue(not req.has_header("Cookie")) @@ -812,17 +812,17 @@ class CookieTests(unittest.TestCase): req = urllib.request.Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) p = pol.set_blocked_domains(["acme.com"]) c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.clear() req = urllib.request.Request("http://www.roadrunner.net/") res = FakeResponse(headers, "http://www.roadrunner.net/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) req = urllib.request.Request("http://www.roadrunner.net/") c.add_cookie_header(req) self.assertTrue((req.has_header("Cookie") and @@ -831,14 +831,14 @@ class CookieTests(unittest.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 = urllib.request.Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") cookies = c.make_cookies(res, req) c.set_cookie(cookies[0]) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) self.assertTrue(not req.has_header("Cookie")) @@ -870,7 +870,7 @@ class CookieTests(unittest.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. @@ -878,7 +878,7 @@ class CookieTests(unittest.TestCase): c = CookieJar(DefaultCookiePolicy(rfc2965=True)) interact_2965(c, url, "foo=bar; Version=1") req = urllib.request.Request(url) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.add_cookie_header(req) self.assertTrue(req.has_header("Cookie")) @@ -990,31 +990,31 @@ class CookieTests(unittest.TestCase): i = 0 for c in cs: self.assertTrue(isinstance(c, Cookie)) - self.assertEquals(c.version, versions[i]) - self.assertEquals(c.name, names[i]) - self.assertEquals(c.domain, domains[i]) - self.assertEquals(c.path, paths[i]) + self.assertEqual(c.version, versions[i]) + self.assertEqual(c.name, names[i]) + self.assertEqual(c.domain, domains[i]) + self.assertEqual(c.path, paths[i]) i = i + 1 def test_parse_ns_headers(self): # missing domain value (invalid cookie) - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo=bar; path=/; domain"]), [[("foo", "bar"), ("path", "/"), ("domain", None), ("version", "0")]] ) # invalid expires value - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]), [[("foo", "bar"), ("expires", None), ("version", "0")]] ) # missing cookie value (valid cookie) - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo"]), [[("foo", None), ("version", "0")]] ) # shouldn't add version if header is empty - self.assertEquals(parse_ns_headers([""]), []) + self.assertEqual(parse_ns_headers([""]), []) def test_bad_cookie_header(self): @@ -1036,7 +1036,7 @@ class CookieTests(unittest.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"] @@ -1175,8 +1175,8 @@ class LWPCookieTests(unittest.TestCase): req = urllib.request.Request("http://www.acme.com/") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), - "PART_NUMBER=ROCKET_LAUNCHER_0001") + self.assertEqual(req.get_header("Cookie"), + "PART_NUMBER=ROCKET_LAUNCHER_0001") headers.append( "Set-Cookie: PART_NUMBER=RIDING_ROCKET_0023; path=/ammo") @@ -1374,40 +1374,40 @@ class LWPCookieTests(unittest.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( @@ -1415,13 +1415,13 @@ class LWPCookieTests(unittest.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 @@ -1432,7 +1432,7 @@ class LWPCookieTests(unittest.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 @@ -1447,7 +1447,7 @@ class LWPCookieTests(unittest.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. @@ -1504,11 +1504,11 @@ class LWPCookieTests(unittest.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.assertTrue("name='foo1', value='bar'" in repr(new_c)) new_c = save_and_restore(c, False) - self.assertEquals(len(new_c), 4) # 2 of them discarded on save + self.assertEqual(len(new_c), 4) # 2 of them discarded on save self.assertTrue("name='foo1', value='bar'" in repr(new_c)) def test_netscape_misc(self): @@ -1553,12 +1553,12 @@ class LWPCookieTests(unittest.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.assertTrue("foo1=bar" in cookie) cookie = interact_netscape(c, "http://example/") self.assertTrue("foo2=bar" in cookie) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) def test_empty_path(self): # Test for empty path @@ -1579,17 +1579,17 @@ class LWPCookieTests(unittest.TestCase): req = urllib.request.Request("http://www.ants.com/") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), - "JSESSIONID=ABCDERANDOM123") - self.assertEquals(req.get_header("Cookie2"), '$Version="1"') + self.assertEqual(req.get_header("Cookie"), + "JSESSIONID=ABCDERANDOM123") + self.assertEqual(req.get_header("Cookie2"), '$Version="1"') # missing path in the request URI req = urllib.request.Request("http://www.ants.com:8080") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), - "JSESSIONID=ABCDERANDOM123") - self.assertEquals(req.get_header("Cookie2"), '$Version="1"') + self.assertEqual(req.get_header("Cookie"), + "JSESSIONID=ABCDERANDOM123") + self.assertEqual(req.get_header("Cookie2"), '$Version="1"') def test_session_cookies(self): year_plus_one = time.localtime()[0] + 1 diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py index ee28316..4c02d90 100644 --- a/Lib/test/test_httplib.py +++ b/Lib/test/test_httplib.py @@ -208,13 +208,13 @@ class BasicTest(TestCase): sock = FakeSocket(None) conn.sock = sock conn.send(expected) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = b'' conn.send(array.array('b', expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = b'' conn.send(io.BytesIO(expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) def test_chunked(self): chunked_start = ( @@ -228,7 +228,7 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = client.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), b'hello world') + self.assertEqual(resp.read(), b'hello world') resp.close() for x in ('', 'foo\r\n'): @@ -238,7 +238,7 @@ class BasicTest(TestCase): try: resp.read() except client.IncompleteRead as i: - self.assertEquals(i.partial, b'hello world') + self.assertEqual(i.partial, b'hello world') self.assertEqual(repr(i),'IncompleteRead(11 bytes read)') self.assertEqual(str(i),'IncompleteRead(11 bytes read)') else: @@ -258,9 +258,9 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = client.HTTPResponse(sock, method="HEAD") resp.begin() - self.assertEquals(resp.read(), b'') - self.assertEquals(resp.status, 200) - self.assertEquals(resp.reason, 'OK') + self.assertEqual(resp.read(), b'') + self.assertEqual(resp.status, 200) + self.assertEqual(resp.reason, 'OK') self.assertTrue(resp.isclosed()) def test_negative_content_length(self): @@ -268,7 +268,7 @@ class BasicTest(TestCase): 'HTTP/1.1 200 OK\r\nContent-Length: -1\r\n\r\nHello\r\n') resp = client.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), b'Hello\r\n') + self.assertEqual(resp.read(), b'Hello\r\n') resp.close() def test_incomplete_read(self): @@ -278,7 +278,7 @@ class BasicTest(TestCase): try: resp.read() except client.IncompleteRead as i: - self.assertEquals(i.partial, b'Hello\r\n') + self.assertEqual(i.partial, b'Hello\r\n') self.assertEqual(repr(i), "IncompleteRead(7 bytes read, 3 more expected)") self.assertEqual(str(i), @@ -305,7 +305,7 @@ class BasicTest(TestCase): class OfflineTest(TestCase): def test_responses(self): - self.assertEquals(client.responses[client.NOT_FOUND], "Not Found") + self.assertEqual(client.responses[client.NOT_FOUND], "Not Found") class TimeoutTest(TestCase): PORT = None diff --git a/Lib/test/test_httpservers.py b/Lib/test/test_httpservers.py index cd6f1cf..6c849a1 100644 --- a/Lib/test/test_httpservers.py +++ b/Lib/test/test_httpservers.py @@ -173,42 +173,42 @@ class BaseHTTPServerTestCase(BaseTestCase): def test_command(self): self.con.request('GET', '/') res = self.con.getresponse() - self.assertEquals(res.status, 501) + self.assertEqual(res.status, 501) def test_request_line_trimming(self): self.con._http_vsn_str = 'HTTP/1.1\n' self.con.putrequest('GET', '/') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 501) + self.assertEqual(res.status, 501) def test_version_bogus(self): self.con._http_vsn_str = 'FUBAR' self.con.putrequest('GET', '/') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 400) + self.assertEqual(res.status, 400) def test_version_digits(self): self.con._http_vsn_str = 'HTTP/9.9.9' self.con.putrequest('GET', '/') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 400) + self.assertEqual(res.status, 400) def test_version_none_get(self): self.con._http_vsn_str = '' self.con.putrequest('GET', '/') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 501) + self.assertEqual(res.status, 501) def test_version_none(self): self.con._http_vsn_str = '' self.con.putrequest('PUT', '/') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 400) + self.assertEqual(res.status, 400) def test_version_invalid(self): self.con._http_vsn = 99 @@ -216,21 +216,21 @@ class BaseHTTPServerTestCase(BaseTestCase): self.con.putrequest('GET', '/') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 505) + self.assertEqual(res.status, 505) def test_send_blank(self): self.con._http_vsn_str = '' self.con.putrequest('', '') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 400) + self.assertEqual(res.status, 400) def test_header_close(self): self.con.putrequest('GET', '/') self.con.putheader('Connection', 'close') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 501) + self.assertEqual(res.status, 501) def test_head_keep_alive(self): self.con._http_vsn_str = 'HTTP/1.1' @@ -238,28 +238,28 @@ class BaseHTTPServerTestCase(BaseTestCase): self.con.putheader('Connection', 'keep-alive') self.con.endheaders() res = self.con.getresponse() - self.assertEquals(res.status, 501) + self.assertEqual(res.status, 501) def test_handler(self): self.con.request('TEST', '/') res = self.con.getresponse() - self.assertEquals(res.status, 204) + self.assertEqual(res.status, 204) def test_return_header_keep_alive(self): self.con.request('KEEP', '/') res = self.con.getresponse() - self.assertEquals(res.getheader('Connection'), 'keep-alive') + self.assertEqual(res.getheader('Connection'), 'keep-alive') self.con.request('TEST', '/') def test_internal_key_error(self): self.con.request('KEYERROR', '/') res = self.con.getresponse() - self.assertEquals(res.status, 999) + self.assertEqual(res.status, 999) def test_return_custom_status(self): self.con.request('CUSTOM', '/') res = self.con.getresponse() - self.assertEquals(res.status, 999) + self.assertEqual(res.status, 999) class SimpleHTTPServerTestCase(BaseTestCase): @@ -291,7 +291,7 @@ class SimpleHTTPServerTestCase(BaseTestCase): def check_status_and_reason(self, response, status, data=None): body = response.read() self.assertTrue(response) - self.assertEquals(response.status, status) + self.assertEqual(response.status, status) self.assertTrue(response.reason != None) if data: self.assertEqual(data, body) @@ -435,13 +435,13 @@ class CGIHTTPServerTestCase(BaseTestCase): server._url_collapse_path_split, path) else: actual = server._url_collapse_path_split(path) - self.assertEquals(expected, actual, - msg='path = %r\nGot: %r\nWanted: %r' % ( - path, actual, expected)) + self.assertEqual(expected, actual, + msg='path = %r\nGot: %r\nWanted: %r' % ( + path, actual, expected)) def test_headers_and_content(self): res = self.request('/cgi-bin/file1.py') - self.assertEquals((b'Hello World\n', 'text/html', 200), \ + self.assertEqual((b'Hello World\n', 'text/html', 200), \ (res.read(), res.getheader('Content-type'), res.status)) def test_post(self): @@ -450,24 +450,24 @@ class CGIHTTPServerTestCase(BaseTestCase): headers = {'Content-type' : 'application/x-www-form-urlencoded'} res = self.request('/cgi-bin/file2.py', 'POST', params, headers) - self.assertEquals(res.read(), b'1, python, 123456\n') + self.assertEqual(res.read(), b'1, python, 123456\n') def test_invaliduri(self): res = self.request('/cgi-bin/invalid') res.read() - self.assertEquals(res.status, 404) + self.assertEqual(res.status, 404) def test_authorization(self): headers = {b'Authorization' : b'Basic ' + base64.b64encode(b'username:pass')} res = self.request('/cgi-bin/file1.py', 'GET', headers=headers) - self.assertEquals((b'Hello World\n', 'text/html', 200), \ + self.assertEqual((b'Hello World\n', 'text/html', 200), \ (res.read(), res.getheader('Content-type'), res.status)) def test_no_leading_slash(self): # http://bugs.python.org/issue2254 res = self.request('cgi-bin/file1.py') - self.assertEquals((b'Hello World\n', 'text/html', 200), + self.assertEqual((b'Hello World\n', 'text/html', 200), (res.read(), res.getheader('Content-type'), res.status)) def test_os_environ_is_not_altered(self): diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py index 58e432a..1ab28c5 100644 --- a/Lib/test/test_imaplib.py +++ b/Lib/test/test_imaplib.py @@ -115,7 +115,7 @@ 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_imp.py b/Lib/test/test_imp.py index d66d40e..1671e48 100644 --- a/Lib/test/test_imp.py +++ b/Lib/test/test_imp.py @@ -70,7 +70,7 @@ class ImportTests(unittest.TestCase): file.write("# coding: cp1252\nu = 'test.test_imp'\n") file, filename, info = imp.find_module(temp_mod_name) file.close() - self.assertEquals(file.encoding, 'cp1252') + self.assertEqual(file.encoding, 'cp1252') finally: del sys.path[0] support.unlink(temp_mod_name + '.py') diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py index adf64e7..e50cd53 100644 --- a/Lib/test/test_import.py +++ b/Lib/test/test_import.py @@ -111,8 +111,8 @@ class ImportTests(unittest.TestCase): if not os.path.exists(fn): raise TestFailed("__import__ did " "not result in creation of either a .pyc or .pyo file") s = os.stat(fn) - self.assertEquals(stat.S_IMODE(s.st_mode), - stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) + self.assertEqual(stat.S_IMODE(s.st_mode), + stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH) finally: os.umask(oldmask) remove_files(TESTFN) diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py index b926d9a..34e0a9a 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -382,8 +382,8 @@ 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 d56e1f0..f7d2318 100644 --- a/Lib/test/test_int.py +++ b/Lib/test/test_int.py @@ -293,7 +293,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 fe361be..acf90df 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -598,7 +598,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 @@ -703,36 +703,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) @@ -740,24 +740,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" @@ -774,34 +774,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()) @support.requires_resource('cpu') def test_threads(self): @@ -927,15 +927,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() @@ -977,11 +977,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, b"".join(writer._write_stack)) + self.assertEqual(contents, b"".join(writer._write_stack)) def test_writes(self): self.check_writes(lambda bufio: None) @@ -1010,11 +1010,11 @@ 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") @@ -1024,11 +1024,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) @@ -1051,7 +1051,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() @@ -1059,7 +1059,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. @@ -1117,7 +1117,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) @@ -1328,45 +1328,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)) @@ -1398,8 +1398,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) @@ -1624,12 +1624,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): @@ -1646,12 +1646,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') @@ -1687,11 +1687,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 @@ -1714,11 +1714,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 @@ -1735,14 +1735,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" ] @@ -1777,14 +1777,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" @@ -1798,9 +1798,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 = { @@ -1817,8 +1817,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 = [] @@ -1832,7 +1832,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 = [] @@ -1879,26 +1879,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() @@ -1923,7 +1923,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") @@ -1933,16 +1933,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): @@ -1950,7 +1950,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 @@ -1959,9 +1959,9 @@ class TextIOWrapperTest(unittest.TestCase): f.close() f = self.open(support.TESTFN, "r", encoding="utf-8") s = f.read(prefix_size) - self.assertEquals(s, str(prefix, "ascii")) - self.assertEquals(f.tell(), prefix_size) - self.assertEquals(f.readline(), u_suffix) + self.assertEqual(s, str(prefix, "ascii")) + self.assertEqual(f.tell(), prefix_size) + self.assertEqual(f.readline(), u_suffix) def test_seeking_too(self): # Regression test for a specific bug @@ -1994,11 +1994,11 @@ 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. @@ -2037,10 +2037,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): @@ -2057,7 +2057,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")) @@ -2077,7 +2077,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") @@ -2089,7 +2089,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") @@ -2101,7 +2101,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") @@ -2112,7 +2112,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") @@ -2120,7 +2120,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") @@ -2130,7 +2130,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) @@ -2146,12 +2146,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 @@ -2166,7 +2166,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: @@ -2194,7 +2194,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") @@ -2248,9 +2248,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") @@ -2299,24 +2299,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 = ( @@ -2337,11 +2337,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) @@ -2374,28 +2374,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 38215d9..26c0d05 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.assertTrue(rpgrp in ids, "%s not in %s" % (rpgrp, ids)) def test_ioctl_mutate(self): diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index 16e65ca..479167e 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -195,7 +195,7 @@ 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 @@ -291,20 +291,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, list(filter(set(cwr).__contains__, perm))) # comb: perm that is a cwr diff --git a/Lib/test/test_keywordonlyarg.py b/Lib/test/test_keywordonlyarg.py index b771a6c..e10dfce 100644 --- a/Lib/test/test_keywordonlyarg.py +++ b/Lib/test/test_keywordonlyarg.py @@ -93,51 +93,51 @@ class KeywordOnlyArgTestCase(unittest.TestCase): pass def testFunctionCall(self): - self.assertEquals(1, posonly_sum(1)) - self.assertEquals(1+2, posonly_sum(1,**{"2":2})) - self.assertEquals(1+2+3, posonly_sum(1,*(2,3))) - self.assertEquals(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) - - self.assertEquals(1, keywordonly_sum(k2=1)) - self.assertEquals(1+2, keywordonly_sum(k1=1, k2=2)) - - self.assertEquals(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) - self.assertEquals(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) - self.assertEquals(1+2+3+4, - keywordonly_and_kwarg_sum(k1=1, k2=2, + self.assertEqual(1, posonly_sum(1)) + self.assertEqual(1+2, posonly_sum(1,**{"2":2})) + self.assertEqual(1+2+3, posonly_sum(1,*(2,3))) + self.assertEqual(1+2+3+4, posonly_sum(1,*(2,3),**{"4":4})) + + self.assertEqual(1, keywordonly_sum(k2=1)) + self.assertEqual(1+2, keywordonly_sum(k1=1, k2=2)) + + self.assertEqual(1+2, keywordonly_and_kwarg_sum(k1=1, k2=2)) + self.assertEqual(1+2+3, keywordonly_and_kwarg_sum(k1=1, k2=2, k3=3)) + self.assertEqual(1+2+3+4, + keywordonly_and_kwarg_sum(k1=1, k2=2, **{"a":3,"b":4})) - self.assertEquals(1+2, mixedargs_sum(1, k1=2)) - self.assertEquals(1+2+3, mixedargs_sum(1, 2, k1=3)) - self.assertEquals(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) - self.assertEquals(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) + self.assertEqual(1+2, mixedargs_sum(1, k1=2)) + self.assertEqual(1+2+3, mixedargs_sum(1, 2, k1=3)) + self.assertEqual(1+2+3+4, mixedargs_sum(1, 2, k1=3, k2=4)) + self.assertEqual(1+2+3+4+5, mixedargs_sum(1, 2, 3, k1=4, k2=5)) - self.assertEquals(1+2, mixedargs_sum2(1, k1=2)) - self.assertEquals(1+2+3, mixedargs_sum2(1, 2, k1=3)) - self.assertEquals(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) - self.assertEquals(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) - self.assertEquals(1+2+3+4+5+6, - mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) - self.assertEquals(1+2+3+4+5+6, - mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) + self.assertEqual(1+2, mixedargs_sum2(1, k1=2)) + self.assertEqual(1+2+3, mixedargs_sum2(1, 2, k1=3)) + self.assertEqual(1+2+3+4, mixedargs_sum2(1, 2, k1=3, k2=4)) + self.assertEqual(1+2+3+4+5, mixedargs_sum2(1, 2, 3, k1=4, k2=5)) + self.assertEqual(1+2+3+4+5+6, + mixedargs_sum2(1, 2, 3, k1=4, k2=5, k3=6)) + self.assertEqual(1+2+3+4+5+6, + mixedargs_sum2(1, 2, 3, k1=4, **{'k2':5, 'k3':6})) - self.assertEquals(1, Foo(k1=1).sum()) - self.assertEquals(1+2, Foo(k1=1,k2=2).sum()) + self.assertEqual(1, Foo(k1=1).sum()) + self.assertEqual(1+2, Foo(k1=1,k2=2).sum()) - self.assertEquals([1,2,3], sortnum(3,2,1)) - self.assertEquals([3,2,1], sortnum(1,2,3, reverse=True)) + self.assertEqual([1,2,3], sortnum(3,2,1)) + self.assertEqual([3,2,1], sortnum(1,2,3, reverse=True)) - self.assertEquals(['a','b','c'], sortwords('a','c','b')) - self.assertEquals(['c','b','a'], sortwords('a','c','b', reverse=True)) - self.assertEquals(['c','b','a'], - sortwords('a','c','b', reverse=True, ignore='ignore')) + self.assertEqual(['a','b','c'], sortwords('a','c','b')) + self.assertEqual(['c','b','a'], sortwords('a','c','b', reverse=True)) + self.assertEqual(['c','b','a'], + sortwords('a','c','b', reverse=True, ignore='ignore')) def testKwDefaults(self): def foo(p1,p2=0, *, k1, k2=0): return p1 + p2 + k1 + k2 - self.assertEquals(2, foo.__code__.co_kwonlyargcount) - self.assertEquals({"k2":0}, foo.__kwdefaults__) + self.assertEqual(2, foo.__code__.co_kwonlyargcount) + self.assertEqual({"k2":0}, foo.__kwdefaults__) foo.__kwdefaults__ = {"k1":0} try: foo(1,k1=10) diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py index 5ba21a2..a90f12c 100644 --- a/Lib/test/test_kqueue.py +++ b/Lib/test/test_kqueue.py @@ -80,7 +80,7 @@ class TestKQueue(unittest.TestCase): try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except socket.error as e: - self.assertEquals(e.args[0], errno.EINPROGRESS) + self.assertEqual(e.args[0], errno.EINPROGRESS) else: #raise AssertionError("Connect should have raised EINPROGRESS") pass # FreeBSD doesn't raise an exception here @@ -114,7 +114,7 @@ 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)]) @@ -133,7 +133,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), @@ -156,7 +156,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() @@ -173,7 +173,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 d4c4777..8e225d5 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 @@ -103,7 +103,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: @@ -114,13 +114,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) diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py index 0575149..05a7f9e 100644 --- a/Lib/test/test_logging.py +++ b/Lib/test/test_logging.py @@ -111,13 +111,13 @@ 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) @@ -689,7 +689,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([]) @@ -807,7 +807,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): diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py index a596cf8..9c2bac7 100644 --- a/Lib/test/test_long.py +++ b/Lib/test/test_long.py @@ -510,9 +510,9 @@ class LongTest(unittest.TestCase): try: int(TruncReturnsNonIntegral()) except TypeError as e: - self.assertEquals(str(e), - "__trunc__ returned non-Integral" - " (type NonIntegral)") + self.assertEqual(str(e), + "__trunc__ returned non-Integral" + " (type NonIntegral)") else: self.fail("Failed to raise TypeError with %s" % ((base, trunc_result_base),)) diff --git a/Lib/test/test_macpath.py b/Lib/test/test_macpath.py index e13865d..b5157bf 100644 --- a/Lib/test/test_macpath.py +++ b/Lib/test/test_macpath.py @@ -45,77 +45,77 @@ class MacPathTestCase(unittest.TestCase): def test_split(self): split = macpath.split - self.assertEquals(split("foo:bar"), - ('foo:', 'bar')) - self.assertEquals(split("conky:mountpoint:foo:bar"), - ('conky:mountpoint:foo', 'bar')) + self.assertEqual(split("foo:bar"), + ('foo:', 'bar')) + self.assertEqual(split("conky:mountpoint:foo:bar"), + ('conky:mountpoint:foo', 'bar')) - self.assertEquals(split(":"), ('', '')) - self.assertEquals(split(":conky:mountpoint:"), - (':conky:mountpoint', '')) + self.assertEqual(split(":"), ('', '')) + self.assertEqual(split(":conky:mountpoint:"), + (':conky:mountpoint', '')) - self.assertEquals(split(b"foo:bar"), - (b'foo:', b'bar')) - self.assertEquals(split(b"conky:mountpoint:foo:bar"), - (b'conky:mountpoint:foo', b'bar')) + self.assertEqual(split(b"foo:bar"), + (b'foo:', b'bar')) + self.assertEqual(split(b"conky:mountpoint:foo:bar"), + (b'conky:mountpoint:foo', b'bar')) - self.assertEquals(split(b":"), (b'', b'')) - self.assertEquals(split(b":conky:mountpoint:"), - (b':conky:mountpoint', b'')) + self.assertEqual(split(b":"), (b'', b'')) + self.assertEqual(split(b":conky:mountpoint:"), + (b':conky:mountpoint', b'')) def test_join(self): join = macpath.join - self.assertEquals(join('a', 'b'), ':a:b') - self.assertEquals(join('', 'a:b'), 'a:b') - self.assertEquals(join('a:b', 'c'), 'a:b:c') - self.assertEquals(join('a:b', ':c'), 'a:b:c') - self.assertEquals(join('a', ':b', ':c'), ':a:b:c') - - self.assertEquals(join(b'a', b'b'), b':a:b') - self.assertEquals(join(b'', b'a:b'), b'a:b') - self.assertEquals(join(b'a:b', b'c'), b'a:b:c') - self.assertEquals(join(b'a:b', b':c'), b'a:b:c') - self.assertEquals(join(b'a', b':b', b':c'), b':a:b:c') + self.assertEqual(join('a', 'b'), ':a:b') + self.assertEqual(join('', 'a:b'), 'a:b') + self.assertEqual(join('a:b', 'c'), 'a:b:c') + self.assertEqual(join('a:b', ':c'), 'a:b:c') + self.assertEqual(join('a', ':b', ':c'), ':a:b:c') + + self.assertEqual(join(b'a', b'b'), b':a:b') + self.assertEqual(join(b'', b'a:b'), b'a:b') + self.assertEqual(join(b'a:b', b'c'), b'a:b:c') + self.assertEqual(join(b'a:b', b':c'), b'a:b:c') + self.assertEqual(join(b'a', b':b', b':c'), b':a:b:c') def test_splitdrive(self): splitdrive = macpath.splitdrive - self.assertEquals(splitdrive("foo:bar"), ('', 'foo:bar')) - self.assertEquals(splitdrive(":foo:bar"), ('', ':foo:bar')) + self.assertEqual(splitdrive("foo:bar"), ('', 'foo:bar')) + self.assertEqual(splitdrive(":foo:bar"), ('', ':foo:bar')) - self.assertEquals(splitdrive(b"foo:bar"), (b'', b'foo:bar')) - self.assertEquals(splitdrive(b":foo:bar"), (b'', b':foo:bar')) + self.assertEqual(splitdrive(b"foo:bar"), (b'', b'foo:bar')) + self.assertEqual(splitdrive(b":foo:bar"), (b'', b':foo:bar')) def test_splitext(self): splitext = macpath.splitext - self.assertEquals(splitext(":foo.ext"), (':foo', '.ext')) - self.assertEquals(splitext("foo:foo.ext"), ('foo:foo', '.ext')) - self.assertEquals(splitext(".ext"), ('.ext', '')) - self.assertEquals(splitext("foo.ext:foo"), ('foo.ext:foo', '')) - self.assertEquals(splitext(":foo.ext:"), (':foo.ext:', '')) - self.assertEquals(splitext(""), ('', '')) - self.assertEquals(splitext("foo.bar.ext"), ('foo.bar', '.ext')) - - self.assertEquals(splitext(b":foo.ext"), (b':foo', b'.ext')) - self.assertEquals(splitext(b"foo:foo.ext"), (b'foo:foo', b'.ext')) - self.assertEquals(splitext(b".ext"), (b'.ext', b'')) - self.assertEquals(splitext(b"foo.ext:foo"), (b'foo.ext:foo', b'')) - self.assertEquals(splitext(b":foo.ext:"), (b':foo.ext:', b'')) - self.assertEquals(splitext(b""), (b'', b'')) - self.assertEquals(splitext(b"foo.bar.ext"), (b'foo.bar', b'.ext')) + self.assertEqual(splitext(":foo.ext"), (':foo', '.ext')) + self.assertEqual(splitext("foo:foo.ext"), ('foo:foo', '.ext')) + self.assertEqual(splitext(".ext"), ('.ext', '')) + self.assertEqual(splitext("foo.ext:foo"), ('foo.ext:foo', '')) + self.assertEqual(splitext(":foo.ext:"), (':foo.ext:', '')) + self.assertEqual(splitext(""), ('', '')) + self.assertEqual(splitext("foo.bar.ext"), ('foo.bar', '.ext')) + + self.assertEqual(splitext(b":foo.ext"), (b':foo', b'.ext')) + self.assertEqual(splitext(b"foo:foo.ext"), (b'foo:foo', b'.ext')) + self.assertEqual(splitext(b".ext"), (b'.ext', b'')) + self.assertEqual(splitext(b"foo.ext:foo"), (b'foo.ext:foo', b'')) + self.assertEqual(splitext(b":foo.ext:"), (b':foo.ext:', b'')) + self.assertEqual(splitext(b""), (b'', b'')) + self.assertEqual(splitext(b"foo.bar.ext"), (b'foo.bar', b'.ext')) def test_ismount(self): ismount = macpath.ismount - self.assertEquals(ismount("a:"), True) - self.assertEquals(ismount("a:b"), False) - self.assertEquals(ismount("a:b:"), True) - self.assertEquals(ismount(""), False) - self.assertEquals(ismount(":"), False) - - self.assertEquals(ismount(b"a:"), True) - self.assertEquals(ismount(b"a:b"), False) - self.assertEquals(ismount(b"a:b:"), True) - self.assertEquals(ismount(b""), False) - self.assertEquals(ismount(b":"), False) + self.assertEqual(ismount("a:"), True) + self.assertEqual(ismount("a:b"), False) + self.assertEqual(ismount("a:b:"), True) + self.assertEqual(ismount(""), False) + self.assertEqual(ismount(":"), False) + + self.assertEqual(ismount(b"a:"), True) + self.assertEqual(ismount(b"a:b"), False) + self.assertEqual(ismount(b"a:b:"), True) + self.assertEqual(ismount(b""), False) + self.assertEqual(ismount(b":"), False) def test_normpath(self): normpath = macpath.normpath diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index 6688785..20f53b8 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -155,8 +155,8 @@ 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 7505948..e53bf2e 100644 --- a/Lib/test/test_math.py +++ b/Lib/test/test_math.py @@ -80,7 +80,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))) @@ -98,8 +98,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): @@ -185,15 +185,15 @@ class MathTests(unittest.TestCase): def testCeil(self): self.assertRaises(TypeError, math.ceil) - self.assertEquals(int, type(math.ceil(0.5))) + self.assertEqual(int, type(math.ceil(0.5))) self.ftest('ceil(0.5)', math.ceil(0.5), 1) self.ftest('ceil(1.0)', math.ceil(1.0), 1) self.ftest('ceil(1.5)', math.ceil(1.5), 2) self.ftest('ceil(-0.5)', math.ceil(-0.5), 0) self.ftest('ceil(-1.0)', math.ceil(-1.0), -1) self.ftest('ceil(-1.5)', math.ceil(-1.5), -1) - #self.assertEquals(math.ceil(INF), INF) - #self.assertEquals(math.ceil(NINF), NINF) + #self.assertEqual(math.ceil(INF), INF) + #self.assertEqual(math.ceil(NINF), NINF) #self.assertTrue(math.isnan(math.ceil(NAN))) class TestCeil: @@ -219,19 +219,19 @@ 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))) @@ -241,7 +241,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) @@ -261,8 +261,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): @@ -276,8 +276,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): @@ -302,7 +302,7 @@ class MathTests(unittest.TestCase): def testFloor(self): self.assertRaises(TypeError, math.floor) - self.assertEquals(int, type(math.floor(0.5))) + self.assertEqual(int, type(math.floor(0.5))) self.ftest('floor(0.5)', math.floor(0.5), 0) self.ftest('floor(1.0)', math.floor(1.0), 1) self.ftest('floor(1.5)', math.floor(1.5), 1) @@ -313,8 +313,8 @@ 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: @@ -345,12 +345,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) @@ -366,8 +366,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])) @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), @@ -481,28 +481,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, 10**10, 10**20, 10**40]: - self.assertEquals(math.ldexp(INF, -n), INF) - self.assertEquals(math.ldexp(NINF, -n), NINF) - self.assertEquals(math.ldexp(1., -n), 0.) - self.assertEquals(math.ldexp(-1., -n), -0.) - self.assertEquals(math.ldexp(0., -n), 0.) - self.assertEquals(math.ldexp(-0., -n), -0.) + self.assertEqual(math.ldexp(INF, -n), INF) + self.assertEqual(math.ldexp(NINF, -n), NINF) + self.assertEqual(math.ldexp(1., -n), 0.) + self.assertEqual(math.ldexp(-1., -n), -0.) + self.assertEqual(math.ldexp(0., -n), 0.) + self.assertEqual(math.ldexp(-0., -n), -0.) self.assertTrue(math.isnan(math.ldexp(NAN, -n))) self.assertRaises(OverflowError, math.ldexp, 1., n) self.assertRaises(OverflowError, math.ldexp, -1., n) - self.assertEquals(math.ldexp(0., n), 0.) - self.assertEquals(math.ldexp(-0., n), -0.) - self.assertEquals(math.ldexp(INF, n), INF) - self.assertEquals(math.ldexp(NINF, n), NINF) + self.assertEqual(math.ldexp(0., n), 0.) + self.assertEqual(math.ldexp(-0., n), -0.) + self.assertEqual(math.ldexp(INF, n), INF) + self.assertEqual(math.ldexp(NINF, n), NINF) self.assertTrue(math.isnan(math.ldexp(NAN, n))) def testLog(self): @@ -513,7 +513,7 @@ 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))) @@ -523,19 +523,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))) @@ -551,8 +551,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])) @@ -731,8 +731,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): @@ -740,7 +740,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))) @@ -799,7 +799,7 @@ class MathTests(unittest.TestCase): # the type only. #t = TestNoTrunc() #t.__trunc__ = lambda *args: args - #self.assertEquals((), math.trunc(t)) + #self.assertEqual((), math.trunc(t)) #self.assertRaises(TypeError, math.trunc, t, 0) def testIsnan(self): diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py index 027ac94..b45845d 100644 --- a/Lib/test/test_memoryio.py +++ b/Lib/test/test_memoryio.py @@ -20,17 +20,17 @@ 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") @@ -38,21 +38,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: diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py index 3f82307..fd820b6 100644 --- a/Lib/test/test_memoryview.py +++ b/Lib/test/test_memoryview.py @@ -27,11 +27,11 @@ 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.assertTrue(isinstance(m[0], bytes), type(m[0])) - self.assertEquals(m[5], item(b"f")) - self.assertEquals(m[-1], item(b"f")) - self.assertEquals(m[-6], item(b"a")) + self.assertEqual(m[5], item(b"f")) + self.assertEqual(m[-1], item(b"f")) + self.assertEqual(m[-6], item(b"a")) # Bounds checking self.assertRaises(IndexError, lambda: m[6]) self.assertRaises(IndexError, lambda: m[-7]) @@ -42,7 +42,7 @@ 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: @@ -66,7 +66,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: @@ -109,7 +109,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: @@ -127,14 +127,14 @@ class AbstractMemoryTests: # This calls self.getitem_type() on each separate byte of b"abcdef" expected = b"".join( self.getitem_type(bytes([c])) for c in b"abcdef") - self.assertEquals(b, expected) + self.assertEqual(b, expected) self.assertTrue(isinstance(b, bytes), type(b)) def test_tolist(self): for tp in self._types: m = self._view(tp(self._source)) l = m.tolist() - self.assertEquals(l, list(b"abcdef")) + self.assertEqual(l, list(b"abcdef")) def test_compare(self): # memoryviews can compare for equality with other objects @@ -168,26 +168,26 @@ class AbstractMemoryTests: def check_attributes_with_type(self, tp): m = self._view(tp(self._source)) - self.assertEquals(m.format, self.format) - self.assertEquals(m.itemsize, self.itemsize) - self.assertEquals(m.ndim, 1) - self.assertEquals(m.shape, (6,)) - self.assertEquals(len(m), 6) - self.assertEquals(m.strides, (self.itemsize,)) - self.assertEquals(m.suboffsets, None) + self.assertEqual(m.format, self.format) + self.assertEqual(m.itemsize, self.itemsize) + self.assertEqual(m.ndim, 1) + self.assertEqual(m.shape, (6,)) + self.assertEqual(len(m), 6) + self.assertEqual(m.strides, (self.itemsize,)) + self.assertEqual(m.suboffsets, None) return m def test_attributes_readonly(self): if not self.ro_type: return m = self.check_attributes_with_type(self.ro_type) - self.assertEquals(m.readonly, True) + self.assertEqual(m.readonly, True) def test_attributes_writable(self): if not self.rw_type: return m = self.check_attributes_with_type(self.rw_type) - self.assertEquals(m.readonly, False) + self.assertEqual(m.readonly, False) def test_getbuffer(self): # Test PyObject_GetBuffer() on a memoryview object. @@ -198,9 +198,9 @@ class AbstractMemoryTests: oldviewrefcount = sys.getrefcount(m) s = str(m, "utf-8") self._check_contents(tp, b, s.encode("utf-8")) - self.assertEquals(sys.getrefcount(m), oldviewrefcount) + self.assertEqual(sys.getrefcount(m), oldviewrefcount) m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_gc(self): for tp in self._types: @@ -262,7 +262,7 @@ 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" @@ -272,14 +272,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" @@ -289,7 +289,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 @@ -316,7 +316,7 @@ class ArrayMemoryviewTest(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_minidom.py b/Lib/test/test_minidom.py index 0a0a663..461ac65 100644 --- a/Lib/test/test_minidom.py +++ b/Lib/test/test_minidom.py @@ -753,7 +753,7 @@ 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) @@ -1223,7 +1223,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 b6d2ffb..fba688e 100644 --- a/Lib/test/test_mmap.py +++ b/Lib/test/test_mmap.py @@ -417,7 +417,7 @@ class MmapTests(unittest.TestCase): data = bytes(reversed(data)) L[start:stop:step] = data m[start:stop:step] = data - self.assertEquals(m[:], bytes(L)) + self.assertEqual(m[:], bytes(L)) def make_mmap_file (self, f, halfsize): # Write 2 pages worth of data to the file @@ -512,27 +512,27 @@ class MmapTests(unittest.TestCase): f.close() # Test write_byte() for i in range(len(data)): - self.assertEquals(m.tell(), i) + self.assertEqual(m.tell(), i) m.write_byte(data[i]) - self.assertEquals(m.tell(), i+1) + self.assertEqual(m.tell(), i+1) self.assertRaises(ValueError, m.write_byte, b"x"[0]) - self.assertEquals(m[:], data) + self.assertEqual(m[:], data) # Test read_byte() m.seek(0) for i in range(len(data)): - self.assertEquals(m.tell(), i) - self.assertEquals(m.read_byte(), data[i]) - self.assertEquals(m.tell(), i+1) + self.assertEqual(m.tell(), i) + self.assertEqual(m.read_byte(), data[i]) + self.assertEqual(m.tell(), i+1) self.assertRaises(ValueError, m.read_byte) # Test read() m.seek(3) - self.assertEquals(m.read(3), b"345") - self.assertEquals(m.tell(), 6) + self.assertEqual(m.read(3), b"345") + self.assertEqual(m.tell(), 6) # Test write() m.seek(3) m.write(b"bar") - self.assertEquals(m.tell(), 6) - self.assertEquals(m[:], b"012bar6789") + self.assertEqual(m.tell(), 6) + self.assertEqual(m[:], b"012bar6789") m.seek(8) self.assertRaises(ValueError, m.write, b"bar") @@ -540,9 +540,9 @@ class MmapTests(unittest.TestCase): for b in (129, 200, 255): # > 128 m = mmap.mmap(-1, 1) m.write_byte(b) - self.assertEquals(m[0], b) + self.assertEqual(m[0], b) m.seek(0) - self.assertEquals(m.read_byte(), b) + self.assertEqual(m.read_byte(), b) m.close() if os.name == 'nt': @@ -556,8 +556,8 @@ 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() @@ -566,8 +566,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 a001e93..52f76ac 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.assertTrue(p not in self.active_children()) self.assertTrue(type(self.active_children()) is list) self.assertEqual(p.exitcode, None) p.start() - self.assertEquals(p.exitcode, None) - self.assertEquals(p.is_alive(), True) + self.assertEqual(p.exitcode, None) + self.assertEqual(p.is_alive(), True) self.assertTrue(p in self.active_children()) - self.assertEquals(q.get(), args[1:]) - self.assertEquals(q.get(), kwargs) - self.assertEquals(q.get(), p.name) + self.assertEqual(q.get(), args[1:]) + self.assertEqual(q.get(), kwargs) + self.assertEqual(q.get(), p.name) if self.TYPE != 'threads': - self.assertEquals(q.get(), current.authkey) - self.assertEquals(q.get(), p.pid) + self.assertEqual(q.get(), current.authkey) + self.assertEqual(q.get(), p.pid) p.join() - self.assertEquals(p.exitcode, 0) - self.assertEquals(p.is_alive(), False) + self.assertEqual(p.exitcode, 0) + self.assertEqual(p.is_alive(), False) self.assertTrue(p not in self.active_children()) @classmethod diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py index 8b7fd9e..9707e84 100644 --- a/Lib/test/test_opcodes.py +++ b/Lib/test/test_opcodes.py @@ -68,35 +68,35 @@ 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 aa3219f..531f56e 100644 --- a/Lib/test/test_operator.py +++ b/Lib/test/test_operator.py @@ -357,12 +357,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 b68e31d..4ad4c0f 100644 --- a/Lib/test/test_optparse.py +++ b/Lib/test/test_optparse.py @@ -425,13 +425,13 @@ 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_type_object(self): self.parser.add_option("-s", type=str) - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") self.parser.add_option("-x", type=int) - self.assertEquals(self.parser.get_option("-x").type, "int") + self.assertEqual(self.parser.get_option("-x").type, "int") # Custom type for testing processing of default values. diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py index 9be1aad..d30c45d 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -223,8 +223,8 @@ 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) import sys @@ -237,8 +237,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.assertTrue(attr in members) try: @@ -292,13 +292,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: @@ -333,7 +333,7 @@ class StatAttributeTests(unittest.TestCase): # time stamps in stat, but not in utime. os.utime(support.TESTFN, (st.st_atime, int(st.st_mtime-delta))) st2 = os.stat(support.TESTFN) - self.assertEquals(st2.st_mtime, int(st.st_mtime-delta)) + self.assertEqual(st2.st_mtime, int(st.st_mtime-delta)) # Restrict test to Win32, since there is no guarantee other # systems support centiseconds @@ -350,7 +350,7 @@ 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 @@ -390,24 +390,24 @@ 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") def test_os_popen_iter(self): if os.path.exists("/bin/sh"): with os.popen( "/bin/sh -c 'echo \"line1\nline2\nline3\"'") as popen: it = iter(popen) - self.assertEquals(next(it), "line1\n") - self.assertEquals(next(it), "line2\n") - self.assertEquals(next(it), "line3\n") + self.assertEqual(next(it), "line1\n") + self.assertEqual(next(it), "line2\n") + self.assertEqual(next(it), "line3\n") self.assertRaises(StopIteration, next, it) # Verify environ keys and values from the OS are of the # correct str type. def test_keyvalue_types(self): for key, val in os.environ.items(): - self.assertEquals(type(key), str) - self.assertEquals(type(val), str) + self.assertEqual(type(key), str) + self.assertEqual(type(val), str) def test_items(self): for key, value in self._reference().items(): @@ -780,7 +780,7 @@ if sys.platform != 'win32': def test_listdir(self): expected = set(self.unicodefn) found = set(os.listdir(support.TESTFN)) - self.assertEquals(found, expected) + self.assertEqual(found, expected) def test_open(self): for fn in self.unicodefn: diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py index 04b45be..9ab4171 100644 --- a/Lib/test/test_parser.py +++ b/Lib/test/test_parser.py @@ -21,8 +21,8 @@ class RoundtripLegalSyntaxTestCase(unittest.TestCase): except parser.ParserError as why: self.fail("could not roundtrip %r: %s" % (s, why)) - self.assertEquals(t, st2.totuple(), - "could not re-generate syntax tree") + self.assertEqual(t, st2.totuple(), + "could not re-generate syntax tree") def check_expr(self, s): self.roundtrip(parser.expr, s) @@ -493,14 +493,14 @@ 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, globs) - self.assertEquals(globs['y'], 5) + self.assertEqual(globs['y'], 5) def test_compile_error(self): st = parser.suite('1 = 3 + 4') @@ -544,36 +544,36 @@ class STObjectTestCase(unittest.TestCase): st3_copy = parser.expr('list(x**3 for x in range(20))') # exercise fast path for object identity - self.assertEquals(st1 == st1, True) - self.assertEquals(st2 == st2, True) - self.assertEquals(st3 == st3, True) + self.assertEqual(st1 == st1, True) + self.assertEqual(st2 == st2, True) + self.assertEqual(st3 == st3, True) # slow path equality self.assertEqual(st1, st1_copy) self.assertEqual(st2, st2_copy) self.assertEqual(st3, st3_copy) - self.assertEquals(st1 == st2, False) - self.assertEquals(st1 == st3, False) - self.assertEquals(st2 == st3, False) - self.assertEquals(st1 != st1, False) - self.assertEquals(st2 != st2, False) - self.assertEquals(st3 != st3, False) - self.assertEquals(st1 != st1_copy, False) - self.assertEquals(st2 != st2_copy, False) - self.assertEquals(st3 != st3_copy, False) - self.assertEquals(st2 != st1, True) - self.assertEquals(st1 != st3, True) - self.assertEquals(st3 != st2, True) + self.assertEqual(st1 == st2, False) + self.assertEqual(st1 == st3, False) + self.assertEqual(st2 == st3, False) + self.assertEqual(st1 != st1, False) + self.assertEqual(st2 != st2, False) + self.assertEqual(st3 != st3, False) + self.assertEqual(st1 != st1_copy, False) + self.assertEqual(st2 != st2_copy, False) + self.assertEqual(st3 != st3_copy, False) + self.assertEqual(st2 != st1, True) + self.assertEqual(st1 != st3, True) + self.assertEqual(st3 != st2, True) # we don't particularly care what the ordering is; just that # it's usable and self-consistent - self.assertEquals(st1 < st2, not (st2 <= st1)) - self.assertEquals(st1 < st3, not (st3 <= st1)) - self.assertEquals(st2 < st3, not (st3 <= st2)) - self.assertEquals(st1 < st2, st2 > st1) - self.assertEquals(st1 < st3, st3 > st1) - self.assertEquals(st2 < st3, st3 > st2) - self.assertEquals(st1 <= st2, st2 >= st1) - self.assertEquals(st3 <= st1, st1 >= st3) - self.assertEquals(st2 <= st3, st3 >= st2) + self.assertEqual(st1 < st2, not (st2 <= st1)) + self.assertEqual(st1 < st3, not (st3 <= st1)) + self.assertEqual(st2 < st3, not (st3 <= st2)) + self.assertEqual(st1 < st2, st2 > st1) + self.assertEqual(st1 < st3, st3 > st1) + self.assertEqual(st2 < st3, st3 > st2) + self.assertEqual(st1 <= st2, st2 >= st1) + self.assertEqual(st3 <= st1, st1 >= st3) + self.assertEqual(st2 <= st3, st3 >= st2) # transitivity bottom = min(st1, st2, st3) top = max(st1, st2, st3) @@ -588,8 +588,8 @@ class STObjectTestCase(unittest.TestCase): self.assertTrue(mid <= mid) self.assertTrue(top <= top) # interaction with other types - self.assertEquals(st1 == 1588.602459, False) - self.assertEquals('spanish armada' != st2, True) + self.assertEqual(st1 == 1588.602459, False) + self.assertEqual('spanish armada' != st2, True) self.assertRaises(TypeError, operator.ge, st3, None) self.assertRaises(TypeError, operator.le, False, st1) self.assertRaises(TypeError, operator.lt, st1, 1815) diff --git a/Lib/test/test_pep247.py b/Lib/test/test_pep247.py index da8f816..7f10472 100644 --- a/Lib/test/test_pep247.py +++ b/Lib/test/test_pep247.py @@ -30,23 +30,23 @@ class Pep247Test(unittest.TestCase): obj3 = cls() obj3.update(b'string') h2 = obj3.digest() - self.assertEquals(h1, h2) + self.assertEqual(h1, h2) self.assertTrue(hasattr(obj1, 'digest_size')) if digest_size is not None: - self.assertEquals(obj1.digest_size, digest_size) + self.assertEqual(obj1.digest_size, digest_size) - self.assertEquals(obj1.digest_size, len(h1)) + self.assertEqual(obj1.digest_size, len(h1)) obj1.update(b'string') obj_copy = obj1.copy() - self.assertEquals(obj1.digest(), obj_copy.digest()) - self.assertEquals(obj1.hexdigest(), obj_copy.hexdigest()) + self.assertEqual(obj1.digest(), obj_copy.digest()) + self.assertEqual(obj1.hexdigest(), obj_copy.hexdigest()) digest, hexdigest = obj1.digest(), obj1.hexdigest() hd2 = "" for byte in digest: hd2 += '%02x' % byte - self.assertEquals(hd2, hexdigest) + self.assertEqual(hd2, hexdigest) def test_md5(self): self.check_object(md5, None, None) diff --git a/Lib/test/test_pep263.py b/Lib/test/test_pep263.py index d5a5b3e..c159af9 100644 --- a/Lib/test/test_pep263.py +++ b/Lib/test/test_pep263.py @@ -26,7 +26,7 @@ class PEP263Test(unittest.TestCase): try: compile(b"# coding: cp932\nprint '\x94\x4e'", "dummy", "exec") except SyntaxError as v: - self.assertEquals(v.text, "print '\u5e74'") + self.assertEqual(v.text, "print '\u5e74'") else: self.fail() @@ -34,7 +34,7 @@ class PEP263Test(unittest.TestCase): c = compile("# coding=latin-1\n\u00c6 = '\u00c6'", "dummy", "exec") d = {} exec(c, d) - self.assertEquals(d['\xc6'], '\xc6') + self.assertEqual(d['\xc6'], '\xc6') def test_issue3297(self): c = compile("a, b = '\U0001010F', '\\U0001010F'", "dummy", "exec") diff --git a/Lib/test/test_pep3131.py b/Lib/test/test_pep3131.py index e4c2d03..3d09ad1 100644 --- a/Lib/test/test_pep3131.py +++ b/Lib/test/test_pep3131.py @@ -9,15 +9,15 @@ class PEP3131Test(unittest.TestCase): ä = 1 µ = 2 # this is a compatibility character 蟒 = 3 - self.assertEquals(getattr(T, "\xe4"), 1) - self.assertEquals(getattr(T, "\u03bc"), 2) - self.assertEquals(getattr(T, '\u87d2'), 3) + self.assertEqual(getattr(T, "\xe4"), 1) + self.assertEqual(getattr(T, "\u03bc"), 2) + self.assertEqual(getattr(T, '\u87d2'), 3) def test_invalid(self): try: from test import badsyntax_3131 except SyntaxError as s: - self.assertEquals(str(s), + self.assertEqual(str(s), "invalid character in identifier (badsyntax_3131.py, line 2)") else: self.fail("expected exception didn't occur") diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py index 466cbe3..4fd286a 100644 --- a/Lib/test/test_platform.py +++ b/Lib/test/test_platform.py @@ -155,17 +155,17 @@ 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") @@ -183,8 +183,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_pow.py b/Lib/test/test_pow.py index 60bb533..20b1066 100644 --- a/Lib/test/test_pow.py +++ b/Lib/test/test_pow.py @@ -5,17 +5,17 @@ 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,): @@ -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(3,3) % 8, pow(3,3,8)) - self.assertEquals(pow(3,3) % -8, pow(3,3,-8)) - self.assertEquals(pow(3,2) % -2, pow(3,2,-2)) - self.assertEquals(pow(-3,3) % 8, pow(-3,3,8)) - self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8)) - self.assertEquals(pow(5,2) % -8, pow(5,2,-8)) + self.assertEqual(pow(3,3) % 8, pow(3,3,8)) + self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) + self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) + self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) + self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) + self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) + + self.assertEqual(pow(3,3) % 8, pow(3,3,8)) + self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) + self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) + self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) + self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) + self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) for i in range(-10, 11): for j in range(0, 6): for k in range(-7, 11): if j >= 0 and k != 0: - self.assertEquals( + self.assertEqual( pow(i,j) % k, pow(i,j,k) ) if j >= 0 and k != 0: - self.assertEquals( + self.assertEqual( pow(int(i),j) % k, pow(int(i),j,k) ) @@ -104,7 +104,7 @@ 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 e74ecd5..92039e4 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(b'', s1) + self.assertEqual(b'', s1) except OSError as 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(b'I wish to buy a fish license.\n', - normalize_output(s1)) + self.assertEqual(b'I wish to buy a fish license.\n', + normalize_output(s1)) debug("Writing chunked output") os.write(slave_fd, TEST_STRING_2[:5]) os.write(slave_fd, TEST_STRING_2[5:]) s2 = os.read(master_fd, 1024) - self.assertEquals(b'For my pet fish, Eric.\n', normalize_output(s2)) + self.assertEqual(b'For my pet fish, Eric.\n', normalize_output(s2)) os.close(slave_fd) os.close(master_fd) diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py index 30d8249..5b6fcb0 100644 --- a/Lib/test/test_pyclbr.py +++ b/Lib/test/test_pyclbr.py @@ -45,7 +45,7 @@ class PyclbrTest(TestCase): def assertEqualsOrIgnored(self, a, b, ignore): ''' succeed iff a == b or a in ignore or b in ignore ''' if a not in ignore and b not in ignore: - self.assertEquals(a, b) + self.assertEqual(a, b) def checkModule(self, moduleName, module=None, ignore=()): ''' succeed iff pyclbr.readmodule_ex(modulename) corresponds @@ -87,7 +87,7 @@ class PyclbrTest(TestCase): self.assertTrue(isinstance(py_item, (FunctionType, BuiltinFunctionType))) if py_item.__module__ != moduleName: continue # skip functions that came from somewhere else - self.assertEquals(py_item.__module__, value.module) + self.assertEqual(py_item.__module__, value.module) else: self.assertTrue(isinstance(py_item, type)) if py_item.__module__ != moduleName: @@ -116,7 +116,7 @@ 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 5ac2a47..133c02b 100644 --- a/Lib/test/test_pyexpat.py +++ b/Lib/test/test_pyexpat.py @@ -24,12 +24,12 @@ class SetAttributeTest(unittest.TestCase): def test_ordered_attributes(self): for x, y in self.set_get_pairs: self.parser.ordered_attributes = x - self.assertEquals(self.parser.ordered_attributes, y) + self.assertEqual(self.parser.ordered_attributes, y) def test_specified_attributes(self): for x, y in self.set_get_pairs: self.parser.specified_attributes = x - self.assertEquals(self.parser.specified_attributes, y) + self.assertEqual(self.parser.specified_attributes, y) data = b'''\ @@ -127,23 +127,23 @@ class ParseTest(unittest.TestCase): ] def _verify_parse_output(self, op): - self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'') - self.assertEquals(op[1], "Comment: ' comment data '") - self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)") - self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')") - self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\u1f40'}") - self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'") - self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}") - self.assertEquals(op[7], "Character data: 'Contents of subelements'") - self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'") - self.assertEquals(op[9], "End of NS decl: 'myns'") - self.assertEquals(op[10], "Start element: 'sub2' {}") - self.assertEquals(op[11], 'Start of CDATA section') - self.assertEquals(op[12], "Character data: 'contents of CDATA section'") - self.assertEquals(op[13], 'End of CDATA section') - self.assertEquals(op[14], "End element: 'sub2'") - self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)") - self.assertEquals(op[16], "End element: 'root'") + self.assertEqual(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'') + self.assertEqual(op[1], "Comment: ' comment data '") + self.assertEqual(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)") + self.assertEqual(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')") + self.assertEqual(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\u1f40'}") + self.assertEqual(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'") + self.assertEqual(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}") + self.assertEqual(op[7], "Character data: 'Contents of subelements'") + self.assertEqual(op[8], "End element: 'http://www.python.org/namespace!subelement'") + self.assertEqual(op[9], "End of NS decl: 'myns'") + self.assertEqual(op[10], "Start element: 'sub2' {}") + self.assertEqual(op[11], 'Start of CDATA section') + self.assertEqual(op[12], "Character data: 'contents of CDATA section'") + self.assertEqual(op[13], 'End of CDATA section') + self.assertEqual(op[14], "End element: 'sub2'") + self.assertEqual(op[15], "External entity ref: (None, 'entity.file', None)") + self.assertEqual(op[16], "End element: 'root'") def test_unicode(self): @@ -184,14 +184,14 @@ class NamespaceSeparatorTest(unittest.TestCase): expat.ParserCreate(namespace_separator=42) self.fail() except TypeError as e: - self.assertEquals(str(e), + self.assertEqual(str(e), 'ParserCreate() argument 2 must be string or None, not int') try: expat.ParserCreate(namespace_separator='too long') self.fail() except ValueError as e: - self.assertEquals(str(e), + self.assertEqual(str(e), 'namespace_separator must be at most one character, omitted, or None') def test_zero_length(self): @@ -217,7 +217,7 @@ 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) @@ -231,7 +231,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(str, expected))) @@ -264,47 +264,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"], - "buffered text not properly split") + self.assertEqual(self.stuff, ["<a>", "1", "<b>", "2", "<c>", "3"], + "buffered text not properly split") def test4(self): self.setHandlers(["StartElementHandler", "EndElementHandler"]) self.parser.CharacterDataHandler = None self.parser.Parse("<a>1<b/>2<c/>3</a>", 1) - self.assertEquals(self.stuff, - ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"]) + self.assertEqual(self.stuff, + ["<a>", "<b>", "</b>", "<c>", "</c>", "</a>"]) def test5(self): self.setHandlers(["StartElementHandler", "EndElementHandler"]) self.parser.Parse("<a>1<b></b>2<c/>3</a>", 1) - self.assertEquals(self.stuff, + self.assertEqual(self.stuff, ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "3", "</a>"]) def test6(self): self.setHandlers(["CommentHandler", "EndElementHandler", "StartElementHandler"]) self.parser.Parse("<a>1<b/>2<c></c>345</a> ", 1) - self.assertEquals(self.stuff, + self.assertEqual(self.stuff, ["<a>", "1", "<b>", "</b>", "2", "<c>", "</c>", "345", "</a>"], "buffered text not properly split") @@ -312,10 +312,10 @@ 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: @@ -330,9 +330,9 @@ class HandlerExceptionTest(unittest.TestCase): parser.Parse("<a><b><c/></b></a>", 1) self.fail() except RuntimeError as e: - self.assertEquals(e.args[0], 'a', - "Expected RuntimeError for element 'a', but" + \ - " found %r" % e.args[0]) + self.assertEqual(e.args[0], 'a', + "Expected RuntimeError for element 'a', but" + \ + " found %r" % e.args[0]) # Test Current* members: @@ -351,7 +351,7 @@ 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 @@ -392,10 +392,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() @@ -418,15 +418,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): @@ -437,27 +437,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) @@ -485,14 +485,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) @@ -501,14 +501,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 = parser.buffer_size // 2 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) parser.Parse(xml2, 1) - self.assertEquals(self.n, 4) + self.assertEqual(self.n, 4) class MalformedInputText(unittest.TestCase): def test1(self): @@ -518,7 +518,7 @@ 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" @@ -527,7 +527,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 95f80ac..c65827d 100644 --- a/Lib/test/test_queue.py +++ b/Lib/test/test_queue.py @@ -99,8 +99,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(q.qsize(), "Queue should not be empty") @@ -158,8 +158,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): for i in range(100): q.put(i) q.join() - self.assertEquals(self.cum, sum(range(100)), - "q.join() did not block until all tasks were done") + self.assertEqual(self.cum, sum(range(100)), + "q.join() did not block until all tasks were done") for i in (0,1): q.put(-1) # instruct the threads to close q.join() # verify that you can join twice diff --git a/Lib/test/test_range.py b/Lib/test/test_range.py index ba028a6..c082fd1 100644 --- a/Lib/test/test_range.py +++ b/Lib/test/test_range.py @@ -105,8 +105,8 @@ class RangeTest(unittest.TestCase): for proto in range(pickle.HIGHEST_PROTOCOL + 1): for t in testcases: r = range(*t) - self.assertEquals(list(pickle.loads(pickle.dumps(r, proto))), - list(r)) + self.assertEqual(list(pickle.loads(pickle.dumps(r, proto))), + list(r)) def test_odd_bug(self): # This used to raise a "SystemError: NULL result without error" diff --git a/Lib/test/test_reprlib.py b/Lib/test/test_reprlib.py index 12e207b..ce6ecb6 100644 --- a/Lib/test/test_reprlib.py +++ b/Lib/test/test_reprlib.py @@ -22,7 +22,7 @@ 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(123), repr(123)) 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)) @@ -133,7 +133,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 @@ -141,13 +141,13 @@ class ReprTests(unittest.TestCase): '<built-in method split of str object at 0x')) def test_range(self): - eq = self.assertEquals + eq = self.assertEqual eq(repr(range(1)), 'range(0, 1)') eq(repr(range(1, 2)), 'range(1, 2)') eq(repr(range(1, 4, 3)), 'range(1, 4, 3)') def test_nesting(self): - eq = self.assertEquals + eq = self.assertEqual # everything is meant to give up after 6 levels. eq(r([[[[[[[]]]]]]]), "[[[[[[[]]]]]]]") eq(r([[[[[[[[]]]]]]]]), "[[[[[[[...]]]]]]]") @@ -168,7 +168,7 @@ 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 @@ -229,7 +229,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 + '.py')) from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation eq(repr(areallylongpackageandmodulenametotestreprtruncation), @@ -237,7 +237,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.py'), '''\ class foo(object): pass @@ -258,7 +258,7 @@ class bar: ''') from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import bar # Module name may be prefixed with "test.", depending on how run. - self.assertEquals(repr(bar.bar), "<class '%s.bar'>" % bar.__name__) + self.assertEqual(repr(bar.bar), "<class '%s.bar'>" % bar.__name__) def test_instance(self): touch(os.path.join(self.subpkgname, 'baz.py'), '''\ @@ -271,7 +271,7 @@ class baz: "<%s.baz object at 0x" % baz.__name__)) def test_method(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'qux.py'), '''\ class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: def amethod(self): pass diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py index c8c7b3a..6c9147a 100644 --- a/Lib/test/test_sax.py +++ b/Lib/test/test_sax.py @@ -27,16 +27,16 @@ 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("attr" in attrs) - self.assertEquals(list(attrs.keys()), []) - self.assertEquals(attrs.get("attrs"), None) - self.assertEquals(attrs.get("attrs", 25), 25) - self.assertEquals(list(attrs.items()), []) - self.assertEquals(list(attrs.values()), []) + self.assertEqual(list(attrs.keys()), []) + self.assertEqual(attrs.get("attrs"), None) + self.assertEqual(attrs.get("attrs", 25), 25) + self.assertEqual(list(attrs.items()), []) + self.assertEqual(list(attrs.values()), []) def verify_empty_nsattrs(self, attrs): self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr")) @@ -44,33 +44,33 @@ 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((ns_uri, "attr") in attrs) - self.assertEquals(list(attrs.keys()), []) - self.assertEquals(attrs.get((ns_uri, "attr")), None) - self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25) - self.assertEquals(list(attrs.items()), []) - self.assertEquals(list(attrs.values()), []) + self.assertEqual(list(attrs.keys()), []) + self.assertEqual(attrs.get((ns_uri, "attr")), None) + self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25) + self.assertEqual(list(attrs.items()), []) + self.assertEqual(list(attrs.values()), []) def verify_attrs_wattr(self, attrs): - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), ["attr"]) - self.assertEquals(attrs.getQNames(), ["attr"]) - self.assertEquals(len(attrs), 1) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), ["attr"]) + self.assertEqual(attrs.getQNames(), ["attr"]) + self.assertEqual(len(attrs), 1) self.assertTrue("attr" in attrs) - self.assertEquals(list(attrs.keys()), ["attr"]) - self.assertEquals(attrs.get("attr"), "val") - self.assertEquals(attrs.get("attr", 25), "val") - self.assertEquals(list(attrs.items()), [("attr", "val")]) - self.assertEquals(list(attrs.values()), ["val"]) - self.assertEquals(attrs.getValue("attr"), "val") - self.assertEquals(attrs.getValueByQName("attr"), "val") - self.assertEquals(attrs.getNameByQName("attr"), "attr") - self.assertEquals(attrs["attr"], "val") - self.assertEquals(attrs.getQNameByName("attr"), "attr") + self.assertEqual(list(attrs.keys()), ["attr"]) + self.assertEqual(attrs.get("attr"), "val") + self.assertEqual(attrs.get("attr", 25), "val") + self.assertEqual(list(attrs.items()), [("attr", "val")]) + self.assertEqual(list(attrs.values()), ["val"]) + self.assertEqual(attrs.getValue("attr"), "val") + self.assertEqual(attrs.getValueByQName("attr"), "val") + self.assertEqual(attrs.getNameByQName("attr"), "attr") + self.assertEqual(attrs["attr"], "val") + self.assertEqual(attrs.getQNameByName("attr"), "attr") class MakeParserTest(unittest.TestCase): def test_make_parser2(self): @@ -100,46 +100,46 @@ class 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"), + self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"), "\"Includes 'single' and "double" quotes\"") # ===== make_parser @@ -162,7 +162,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() @@ -174,7 +174,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() @@ -186,7 +186,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() @@ -198,7 +198,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): @@ -216,7 +216,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>")) @@ -231,7 +231,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() @@ -247,7 +247,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)) @@ -260,7 +260,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() @@ -273,7 +273,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() @@ -286,7 +286,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): @@ -309,11 +309,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 @@ -337,11 +337,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): @@ -358,7 +358,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>") # =========================================================================== # @@ -380,7 +380,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(open(findfile("test.xml"))) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== DTDHandler support @@ -408,9 +408,9 @@ 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 @@ -433,8 +433,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 @@ -486,18 +486,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((ns_uri, "attr") in attrs) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")]) - self.assertEquals(list(attrs.values()), ["val"]) - self.assertEquals(attrs.getValue((ns_uri, "attr")), "val") - self.assertEquals(attrs[(ns_uri, "attr")], "val") + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")]) + self.assertEqual(list(attrs.values()), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs[(ns_uri, "attr")], "val") # ===== InputSource support @@ -509,7 +509,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(findfile("test.xml")) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_sysid(self): parser = create_parser() @@ -519,7 +519,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(InputSource(findfile("test.xml"))) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_stream(self): parser = create_parser() @@ -531,7 +531,7 @@ class ExpatReaderTest(XmlTestBase): inpsrc.setByteStream(open(findfile("test.xml"))) parser.parse(inpsrc) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== IncrementalParser support @@ -545,7 +545,7 @@ 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() @@ -566,7 +566,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 @@ -580,9 +580,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() @@ -591,8 +591,8 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(findfile("test.xml")) - self.assertEquals(parser.getSystemId(), findfile("test.xml")) - self.assertEquals(parser.getPublicId(), None) + self.assertEqual(parser.getSystemId(), findfile("test.xml")) + self.assertEqual(parser.getPublicId(), None) # =========================================================================== @@ -613,7 +613,7 @@ class ErrorReportingTest(unittest.TestCase): parser.parse(source) self.fail() except SAXException as e: - self.assertEquals(e.getSystemId(), name) + self.assertEqual(e.getSystemId(), name) def test_expat_incomplete(self): parser = create_parser() @@ -677,21 +677,21 @@ 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((ns_uri, "attr") in attrs) - self.assertEquals(list(attrs.keys()), [(ns_uri, "attr")]) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(list(attrs.items()), [((ns_uri, "attr"), "val")]) - self.assertEquals(list(attrs.values()), ["val"]) - self.assertEquals(attrs.getValue((ns_uri, "attr")), "val") - self.assertEquals(attrs.getValueByQName("ns:attr"), "val") - self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr")) - self.assertEquals(attrs[(ns_uri, "attr")], "val") - self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr") + self.assertEqual(list(attrs.keys()), [(ns_uri, "attr")]) + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(list(attrs.items()), [((ns_uri, "attr"), "val")]) + self.assertEqual(list(attrs.values()), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs.getValueByQName("ns:attr"), "val") + self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr")) + self.assertEqual(attrs[(ns_uri, "attr")], "val") + self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr") # During the development of Python 2.5, an attempt to move the "xml" @@ -727,7 +727,7 @@ 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 5f8768a..fb97f1b 100644 --- a/Lib/test/test_scope.py +++ b/Lib/test/test_scope.py @@ -498,7 +498,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_signal.py b/Lib/test/test_signal.py index 83ac669..8f9b064 100644 --- a/Lib/test/test_signal.py +++ b/Lib/test/test_signal.py @@ -203,10 +203,10 @@ 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_slice.py b/Lib/test/test_slice.py index 2ecb59a..2df9271 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -118,7 +118,7 @@ class SliceTest(unittest.TestCase): x = X() x[1:2] = 42 - self.assertEquals(tmp, [(slice(1, 2), 42)]) + self.assertEqual(tmp, [(slice(1, 2), 42)]) def test_pickle(self): s = slice(10, 20, 3) diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py index 98ba4df..0bb43d3 100644 --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -425,8 +425,8 @@ 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(b'\x00'*4, socket.inet_aton('0.0.0.0')) - self.assertEquals(b'\xff'*4, socket.inet_aton('255.255.255.255')) + self.assertEqual(b'\x00'*4, socket.inet_aton('0.0.0.0')) + self.assertEqual(b'\xff'*4, socket.inet_aton('255.255.255.255')) def testIPv4toString(self): if not hasattr(socket, 'inet_pton'): @@ -434,16 +434,16 @@ 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(b'\x00\x00\x00\x00', f('0.0.0.0')) - self.assertEquals(b'\xff\x00\xff\x00', f('255.0.255.0')) - self.assertEquals(b'\xaa\xaa\xaa\xaa', f('170.170.170.170')) - self.assertEquals(b'\x01\x02\x03\x04', f('1.2.3.4')) - self.assertEquals(b'\xff\xff\xff\xff', f('255.255.255.255')) + self.assertEqual(b'\x00\x00\x00\x00', f('0.0.0.0')) + self.assertEqual(b'\xff\x00\xff\x00', f('255.0.255.0')) + self.assertEqual(b'\xaa\xaa\xaa\xaa', f('170.170.170.170')) + self.assertEqual(b'\x01\x02\x03\x04', f('1.2.3.4')) + self.assertEqual(b'\xff\xff\xff\xff', f('255.255.255.255')) - self.assertEquals(b'\x00\x00\x00\x00', g('0.0.0.0')) - self.assertEquals(b'\xff\x00\xff\x00', g('255.0.255.0')) - self.assertEquals(b'\xaa\xaa\xaa\xaa', g('170.170.170.170')) - self.assertEquals(b'\xff\xff\xff\xff', g('255.255.255.255')) + self.assertEqual(b'\x00\x00\x00\x00', g('0.0.0.0')) + self.assertEqual(b'\xff\x00\xff\x00', g('255.0.255.0')) + self.assertEqual(b'\xaa\xaa\xaa\xaa', g('170.170.170.170')) + self.assertEqual(b'\xff\xff\xff\xff', g('255.255.255.255')) def testIPv6toString(self): if not hasattr(socket, 'inet_pton'): @@ -456,10 +456,10 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_pton(AF_INET6, a) - self.assertEquals(b'\x00' * 16, f('::')) - self.assertEquals(b'\x00' * 16, f('0::0')) - self.assertEquals(b'\x00\x01' + b'\x00' * 14, f('1::')) - self.assertEquals( + self.assertEqual(b'\x00' * 16, f('::')) + self.assertEqual(b'\x00' * 16, f('0::0')) + self.assertEqual(b'\x00\x01' + b'\x00' * 14, f('1::')) + self.assertEqual( b'\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae', f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae') ) @@ -470,14 +470,14 @@ 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(b'\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', f(b'\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', f(b'\xff\xff\xff\xff')) - self.assertEquals('1.2.3.4', f(b'\x01\x02\x03\x04')) + self.assertEqual('1.0.1.0', f(b'\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', f(b'\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', f(b'\xff\xff\xff\xff')) + self.assertEqual('1.2.3.4', f(b'\x01\x02\x03\x04')) - self.assertEquals('1.0.1.0', g(b'\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', g(b'\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', g(b'\xff\xff\xff\xff')) + self.assertEqual('1.0.1.0', g(b'\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', g(b'\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', g(b'\xff\xff\xff\xff')) def testStringToIPv6(self): if not hasattr(socket, 'inet_ntop'): @@ -490,9 +490,9 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_ntop(AF_INET6, a) - self.assertEquals('::', f(b'\x00' * 16)) - self.assertEquals('::1', f(b'\x00' * 15 + b'\x01')) - self.assertEquals( + self.assertEqual('::', f(b'\x00' * 16)) + self.assertEqual('::1', f(b'\x00' * 15 + b'\x01')) + self.assertEqual( 'aef:b01:506:1001:ffff:9997:55:170', f(b'\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70') ) @@ -1193,7 +1193,7 @@ class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest): self.cli = socket.create_connection((HOST, self.port)) finally: socket.setdefaulttimeout(None) - self.assertEquals(self.cli.gettimeout(), 42) + self.assertEqual(self.cli.gettimeout(), 42) testTimeoutNone = _justAccept def _testTimeoutNone(self): diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py index 6819f30..a098edd 100644 --- a/Lib/test/test_socketserver.py +++ b/Lib/test/test_socketserver.py @@ -57,8 +57,8 @@ 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 def run_server(self, svrcls, hdlrbase, testfunc): @@ -159,7 +159,7 @@ class SocketServerTest(unittest.TestCase): while data and b'\n' not in buf: data = receive(s, 100) buf += data - self.assertEquals(buf, TEST_STR) + self.assertEqual(buf, TEST_STR) s.close() def dgram_examine(self, proto, addr): @@ -169,7 +169,7 @@ class SocketServerTest(unittest.TestCase): while data and b'\n' not in buf: data = receive(s, 100) buf += data - self.assertEquals(buf, TEST_STR) + self.assertEqual(buf, TEST_STR) s.close() def test_TCPServer(self): diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py index 9d82f38..41bcac9 100644 --- a/Lib/test/test_structmembers.py +++ b/Lib/test/test_structmembers.py @@ -28,64 +28,64 @@ 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) def test_py_ssize_t(self): ts.T_PYSSIZET = PY_SSIZE_T_MAX - self.assertEquals(ts.T_PYSSIZET, PY_SSIZE_T_MAX) + self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MAX) ts.T_PYSSIZET = PY_SSIZE_T_MIN - self.assertEquals(ts.T_PYSSIZET, PY_SSIZE_T_MIN) + self.assertEqual(ts.T_PYSSIZET, PY_SSIZE_T_MIN) @unittest.skipUnless(hasattr(ts, "T_LONGLONG"), "long long not present") def test_longlong(self): ts.T_LONGLONG = LLONG_MAX - self.assertEquals(ts.T_LONGLONG, LLONG_MAX) + self.assertEqual(ts.T_LONGLONG, LLONG_MAX) ts.T_LONGLONG = LLONG_MIN - self.assertEquals(ts.T_LONGLONG, LLONG_MIN) + self.assertEqual(ts.T_LONGLONG, LLONG_MIN) ts.T_ULONGLONG = ULLONG_MAX - self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX) + self.assertEqual(ts.T_ULONGLONG, ULLONG_MAX) ## make sure these will accept a plain int as well as a long ts.T_LONGLONG = 3 - self.assertEquals(ts.T_LONGLONG, 3) + self.assertEqual(ts.T_LONGLONG, 3) ts.T_ULONGLONG = 4 - self.assertEquals(ts.T_ULONGLONG, 4) + self.assertEqual(ts.T_ULONGLONG, 4) def test_bad_assignments(self): integer_attributes = [ @@ -106,7 +106,7 @@ class ReadWriteTests(unittest.TestCase): self.assertRaises(TypeError, setattr, ts, attr, nonint) def test_inplace_string(self): - self.assertEquals(ts.T_STRING_INPLACE, "hi") + self.assertEqual(ts.T_STRING_INPLACE, "hi") self.assertRaises(TypeError, setattr, ts, "T_STRING_INPLACE", "s") self.assertRaises(TypeError, delattr, ts, "T_STRING_INPLACE") diff --git a/Lib/test/test_subprocess.py b/Lib/test/test_subprocess.py index f2dbdc2..2379b3e 100644 --- a/Lib/test/test_subprocess.py +++ b/Lib/test/test_subprocess.py @@ -276,7 +276,7 @@ class ProcessTestCase(BaseTestCase): # stdout is set to 1 (#1531862). cmd = r"import sys, os; sys.exit(os.write(sys.stdout.fileno(), b'.\n'))" rc = subprocess.call([sys.executable, "-c", cmd], stdout=1) - self.assertEquals(rc, 2) + self.assertEqual(rc, 2) def test_cwd(self): tmpdir = tempfile.gettempdir() @@ -566,7 +566,7 @@ class ProcessTestCase(BaseTestCase): "[sys.executable, '-c', 'print(\"Hello World!\")'])", 'assert retcode == 0')) output = subprocess.check_output([sys.executable, '-c', code]) - self.assert_(output.startswith(b'Hello World!'), ascii(output)) + self.assertTrue(output.startswith(b'Hello World!'), ascii(output)) def test_handles_closed_on_exception(self): # If CreateProcess exits with an error, ensure the @@ -779,7 +779,7 @@ class ProcessTestCase(BaseTestCase): [sys.executable, "-c", script], env=env) stdout = stdout.rstrip(b'\n\r') - self.assertEquals(stdout, value_repr) + self.assertEqual(stdout, value_repr) # test bytes key = key.encode("ascii", "surrogateescape") @@ -791,7 +791,7 @@ class ProcessTestCase(BaseTestCase): [sys.executable, "-c", script], env=env) stdout = stdout.rstrip(b'\n\r') - self.assertEquals(stdout, value_repr) + self.assertEqual(stdout, value_repr) # # Windows tests @@ -897,9 +897,9 @@ class CommandTests(unittest.TestCase): if os.name == 'posix': def test_getoutput(self): - self.assertEquals(subprocess.getoutput('echo xyzzy'), 'xyzzy') - self.assertEquals(subprocess.getstatusoutput('echo xyzzy'), - (0, 'xyzzy')) + self.assertEqual(subprocess.getoutput('echo xyzzy'), 'xyzzy') + self.assertEqual(subprocess.getstatusoutput('echo xyzzy'), + (0, 'xyzzy')) # we use mkdtemp in the next line to create an empty directory # under our exclusive control; from that, we can invent a pathname @@ -910,7 +910,7 @@ class CommandTests(unittest.TestCase): name = os.path.join(dir, "foo") status, output = subprocess.getstatusoutput('cat ' + name) - self.assertNotEquals(status, 0) + self.assertNotEqual(status, 0) finally: if dir is not None: os.rmdir(dir) diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index ccad44a..aa30923 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -86,7 +86,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(0) except SystemExit as exc: - self.assertEquals(exc.code, 0) + self.assertEqual(exc.code, 0) except: self.fail("wrong exception") else: @@ -97,7 +97,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(42) except SystemExit as exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -107,7 +107,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((42,)) except SystemExit as exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -117,7 +117,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit("exit") except SystemExit as exc: - self.assertEquals(exc.code, "exit") + self.assertEqual(exc.code, "exit") except: self.fail("wrong exception") else: @@ -127,7 +127,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((17, 23)) except SystemExit as exc: - self.assertEquals(exc.code, (17, 23)) + self.assertEqual(exc.code, (17, 23)) except: self.fail("wrong exception") else: @@ -171,7 +171,7 @@ 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) @@ -438,8 +438,8 @@ class SysModuleTest(unittest.TestCase): p = subprocess.Popen([sys.executable, "-c", code], stderr=subprocess.PIPE) stdout, stderr = p.communicate() self.assertEqual(p.returncode, 1) - self.assert_(b"UnicodeEncodeError:" in stderr, - "%r not in %s" % (b"UniodeEncodeError:", ascii(stderr))) + self.assertTrue(b"UnicodeEncodeError:" in stderr, + "%r not in %s" % (b"UnicodeEncodeError:", ascii(stderr))) def test_sys_flags(self): self.assertTrue(sys.flags) diff --git a/Lib/test/test_tempfile.py b/Lib/test/test_tempfile.py index 403dd93..f48ab88 100644 --- a/Lib/test/test_tempfile.py +++ b/Lib/test/test_tempfile.py @@ -314,7 +314,7 @@ class test__mkstemp_inner(TC): f.write(b"blat\x1a") f.write(b"extra\n") os.lseek(f.fd, 0, os.SEEK_SET) - self.assertEquals(os.read(f.fd, 20), b"blat") + self.assertEqual(os.read(f.fd, 20), b"blat") test_classes.append(test__mkstemp_inner) @@ -872,7 +872,7 @@ class test_TemporaryFile(TC): with tempfile.TemporaryFile(*args, **kwargs) as fileobj: fileobj.write(input) fileobj.seek(0) - self.assertEquals(input, fileobj.read()) + self.assertEqual(input, fileobj.read()) roundtrip(b"1234", "w+b") roundtrip("abdc\n", "w+") diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py index ffd59c3..905dd4c 100644 --- a/Lib/test/test_textwrap.py +++ b/Lib/test/test_textwrap.py @@ -29,7 +29,7 @@ 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): @@ -490,7 +490,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. @@ -513,17 +513,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. @@ -537,27 +537,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* @@ -573,17 +573,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_thread.py b/Lib/test/test_thread.py index f6ce1ae..a86f86b 100644 --- a/Lib/test/test_thread.py +++ b/Lib/test/test_thread.py @@ -61,10 +61,10 @@ class ThreadRunningTests(BasicThreadTest): def test_stack_size(self): # Various stack size tests. - self.assertEquals(thread.stack_size(), 0, "intial stack size is not 0") + self.assertEqual(thread.stack_size(), 0, "intial stack size is not 0") thread.stack_size(0) - self.assertEquals(thread.stack_size(), 0, "stack_size not reset to default") + self.assertEqual(thread.stack_size(), 0, "stack_size not reset to default") if os.name not in ("nt", "os2", "posix"): return @@ -84,7 +84,7 @@ class ThreadRunningTests(BasicThreadTest): fail_msg = "stack_size(%d) failed - should succeed" for tss in (262144, 0x100000, 0): thread.stack_size(tss) - self.assertEquals(thread.stack_size(), tss, fail_msg % tss) + self.assertEqual(thread.stack_size(), tss, fail_msg % tss) verbose_print("successfully set stack_size(%d)" % tss) for tss in (262144, 0x100000): diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py index 6d84e7e..745c602 100644 --- a/Lib/test/test_threadedtempfile.py +++ b/Lib/test/test_threadedtempfile.py @@ -69,8 +69,8 @@ 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 f691336..587004a 100644 --- a/Lib/test/test_threading.py +++ b/Lib/test/test_threading.py @@ -371,17 +371,17 @@ class ThreadTests(unittest.TestCase): weak_cyclic_object = weakref.ref(cyclic_object) cyclic_object.thread.join() del cyclic_object - self.assertEquals(None, weak_cyclic_object(), - msg=('%d references still around' % - sys.getrefcount(weak_cyclic_object()))) + self.assertEqual(None, weak_cyclic_object(), + msg=('%d references still around' % + sys.getrefcount(weak_cyclic_object()))) raising_cyclic_object = RunSelfFunction(should_raise=True) weak_raising_cyclic_object = weakref.ref(raising_cyclic_object) raising_cyclic_object.thread.join() del raising_cyclic_object - self.assertEquals(None, weak_raising_cyclic_object(), - msg=('%d references still around' % - sys.getrefcount(weak_raising_cyclic_object()))) + self.assertEqual(None, weak_raising_cyclic_object(), + msg=('%d references still around' % + sys.getrefcount(weak_raising_cyclic_object()))) def test_old_threading_api(self): # Just a quick sanity check to make sure the old method names are diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py index 49a9d17..4b5d703 100644 --- a/Lib/test/test_time.py +++ b/Lib/test/test_time.py @@ -99,7 +99,7 @@ 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_tokenize.py b/Lib/test/test_tokenize.py index 482af94..510e632 100644 --- a/Lib/test/test_tokenize.py +++ b/Lib/test/test_tokenize.py @@ -690,8 +690,8 @@ class Test_Tokenize(TestCase): # skip the initial encoding token and the end token tokens = list(_tokenize(readline, encoding='utf-8'))[1:-1] expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')] - self.assertEquals(tokens, expected_tokens, - "bytes not decoded with encoding") + self.assertEqual(tokens, expected_tokens, + "bytes not decoded with encoding") def test__tokenize_does_not_decode_with_encoding_none(self): literal = '"ЉЊЈЁЂ"' @@ -707,8 +707,8 @@ class Test_Tokenize(TestCase): # skip the end token tokens = list(_tokenize(readline, encoding=None))[:-1] expected_tokens = [(3, '"ЉЊЈЁЂ"', (1, 0), (1, 7), '"ЉЊЈЁЂ"')] - self.assertEquals(tokens, expected_tokens, - "string not tokenized when encoding is None") + self.assertEqual(tokens, expected_tokens, + "string not tokenized when encoding is None") class TestDetectEncoding(TestCase): @@ -731,8 +731,8 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, list(lines[:2])) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, list(lines[:2])) def test_bom_no_cookie(self): lines = ( @@ -741,9 +741,9 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, - [b'# something\n', b'print(something)\n']) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, + [b'# something\n', b'print(something)\n']) def test_cookie_first_line_no_bom(self): lines = ( @@ -752,8 +752,8 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'iso-8859-1') - self.assertEquals(consumed_lines, [b'# -*- coding: latin-1 -*-\n']) + self.assertEqual(encoding, 'iso-8859-1') + self.assertEqual(consumed_lines, [b'# -*- coding: latin-1 -*-\n']) def test_matched_bom_and_cookie_first_line(self): lines = ( @@ -762,8 +762,8 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, [b'# coding=utf-8\n']) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, [b'# coding=utf-8\n']) def test_mismatched_bom_and_cookie_first_line_raises_syntaxerror(self): lines = ( @@ -782,9 +782,9 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'ascii') + self.assertEqual(encoding, 'ascii') expected = [b'#! something\n', b'# vim: set fileencoding=ascii :\n'] - self.assertEquals(consumed_lines, expected) + self.assertEqual(consumed_lines, expected) def test_matched_bom_and_cookie_second_line(self): lines = ( @@ -794,9 +794,9 @@ class TestDetectEncoding(TestCase): b'do_something(else)\n' ) encoding, consumed_lines = detect_encoding(self.get_readline(lines)) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, - [b'#! something\n', b'f# coding=utf-8\n']) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, + [b'#! something\n', b'f# coding=utf-8\n']) def test_mismatched_bom_and_cookie_second_line_raises_syntaxerror(self): lines = ( @@ -821,7 +821,7 @@ class TestDetectEncoding(TestCase): b"do_something += 4\n") rl = self.get_readline(lines) found, consumed_lines = detect_encoding(rl) - self.assertEquals(found, "iso-8859-1") + self.assertEqual(found, "iso-8859-1") def test_utf8_normalization(self): # See get_normal_name() in tokenizer.c. @@ -834,27 +834,27 @@ class TestDetectEncoding(TestCase): b"1 + 3\n") rl = self.get_readline(lines) found, consumed_lines = detect_encoding(rl) - self.assertEquals(found, "utf-8") + self.assertEqual(found, "utf-8") def test_short_files(self): readline = self.get_readline((b'print(something)\n',)) encoding, consumed_lines = detect_encoding(readline) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, [b'print(something)\n']) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, [b'print(something)\n']) encoding, consumed_lines = detect_encoding(self.get_readline(())) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, []) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, []) readline = self.get_readline((b'\xef\xbb\xbfprint(something)\n',)) encoding, consumed_lines = detect_encoding(readline) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, [b'print(something)\n']) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, [b'print(something)\n']) readline = self.get_readline((b'\xef\xbb\xbf',)) encoding, consumed_lines = detect_encoding(readline) - self.assertEquals(encoding, 'utf-8') - self.assertEquals(consumed_lines, []) + self.assertEqual(encoding, 'utf-8') + self.assertEqual(consumed_lines, []) readline = self.get_readline((b'# coding: bad\n',)) self.assertRaises(SyntaxError, detect_encoding, readline) @@ -893,7 +893,7 @@ class TestTokenize(TestCase): tokenize_module._tokenize = mock__tokenize try: results = tokenize(mock_readline) - self.assertEquals(list(results), ['first', 'second', 1, 2, 3, 4]) + self.assertEqual(list(results), ['first', 'second', 1, 2, 3, 4]) finally: tokenize_module.detect_encoding = orig_detect_encoding tokenize_module._tokenize = orig__tokenize diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py index 99d6a12..07c5062 100644 --- a/Lib/test/test_trace.py +++ b/Lib/test/test_trace.py @@ -289,7 +289,7 @@ 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 b2c7262..f9e4458 100644 --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -171,11 +171,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')) @@ -219,7 +219,7 @@ class BaseExceptionReportingTests: except ZeroDivisionError as _: e = _ lines = self.get_report(e).splitlines() - self.assertEquals(len(lines), 4) + self.assertEqual(len(lines), 4) self.assertTrue(lines[0].startswith('Traceback')) self.assertTrue(lines[1].startswith(' File')) self.assertTrue('1/0 # Marker' in lines[2]) @@ -234,8 +234,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], cause_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], cause_message) self.check_zero_div(blocks[0]) self.assertTrue('inner_raise() # Marker' in blocks[2]) @@ -248,8 +248,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], context_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], context_message) self.check_zero_div(blocks[0]) self.assertTrue('inner_raise() # Marker' in blocks[2]) @@ -268,10 +268,10 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], cause_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], cause_message) self.check_zero_div(blocks[0]) - self.assert_('inner_raise() # Marker' in blocks[2]) + self.assertIn('inner_raise() # Marker', blocks[2]) def test_cause_recursive(self): def inner_raise(): @@ -286,8 +286,8 @@ class BaseExceptionReportingTests: def outer_raise(): inner_raise() # Marker blocks = boundaries.split(self.get_report(outer_raise)) - self.assertEquals(len(blocks), 3) - self.assertEquals(blocks[1], cause_message) + self.assertEqual(len(blocks), 3) + self.assertEqual(blocks[1], cause_message) # The first block is the KeyError raised from the ZeroDivisionError self.assertTrue('raise KeyError from e' in blocks[0]) self.assertTrue('1/0' not in blocks[0]) @@ -320,7 +320,7 @@ class PyExcReportingTests(BaseExceptionReportingTests, unittest.TestCase): traceback.format_exception(type(e), e, e.__traceback__)) with captured_output("stderr") as sio: traceback.print_exception(type(e), e, e.__traceback__) - self.assertEquals(sio.getvalue(), s) + self.assertEqual(sio.getvalue(), s) return s diff --git a/Lib/test/test_unicode.py b/Lib/test/test_unicode.py index 36a25c3..4793707 100644 --- a/Lib/test/test_unicode.py +++ b/Lib/test/test_unicode.py @@ -68,7 +68,7 @@ class UnicodeTest( self.assertRaises(SyntaxError, eval, '\'\\Uffffffff\'') self.assertRaises(SyntaxError, eval, '\'\\U%08x\'' % 0x110000) # raw strings should not have unicode escapes - self.assertNotEquals(r"\u0020", " ") + self.assertNotEqual(r"\u0020", " ") def test_ascii(self): if not sys.platform.startswith('java'): @@ -1379,8 +1379,8 @@ class UnicodeTest( def __str__(self): return '__str__ overridden' s = S('xxx') - self.assertEquals("%s" % s, '__str__ overridden') - self.assertEquals("{}".format(s), '__str__ overridden') + self.assertEqual("%s" % s, '__str__ overridden') + self.assertEqual("{}".format(s), '__str__ overridden') def test_main(): diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py index 43ac879..f8df2b6 100644 --- a/Lib/test/test_unicodedata.py +++ b/Lib/test/test_unicodedata.py @@ -253,7 +253,7 @@ 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"), '\U00010346') + self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), '\U00010346') def test_ucd_510(self): import unicodedata diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py index d59bf8a..ae91a87 100644 --- a/Lib/test/test_unittest.py +++ b/Lib/test/test_unittest.py @@ -2926,7 +2926,7 @@ class Test_Assertions(TestCase): try: self.assertRaises(KeyError, lambda: None) except self.failureException as e: - self.assert_("KeyError not raised" in str(e), str(e)) + self.assertIn("KeyError not raised", str(e)) else: self.fail("assertRaises() didn't fail") try: @@ -2943,7 +2943,7 @@ class Test_Assertions(TestCase): with self.assertRaises(KeyError): pass except self.failureException as e: - self.assert_("KeyError not raised" in str(e), str(e)) + self.assertIn("KeyError not raised", str(e)) else: self.fail("assertRaises() didn't fail") try: @@ -2982,11 +2982,11 @@ class TestLongMessage(TestCase): self.assertFalse(TestCase.longMessage) def test_formatMsg(self): - self.assertEquals(self.testableFalse._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableFalse._formatMessage("foo", "bar"), "foo") + self.assertEqual(self.testableFalse._formatMessage(None, "foo"), "foo") + self.assertEqual(self.testableFalse._formatMessage("foo", "bar"), "foo") - self.assertEquals(self.testableTrue._formatMessage(None, "foo"), "foo") - self.assertEquals(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") + self.assertEqual(self.testableTrue._formatMessage(None, "foo"), "foo") + self.assertEqual(self.testableTrue._formatMessage("foo", "bar"), "bar : foo") def assertMessages(self, methodName, args, errors): def getMethod(i): diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py index 33c4e65..2b41ba1 100644 --- a/Lib/test/test_warnings.py +++ b/Lib/test/test_warnings.py @@ -81,7 +81,7 @@ 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, @@ -103,10 +103,10 @@ class FilterTests(object): for x in range(2): self.module.warn(message, UserWarning) if x == 0: - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] elif x == 1: - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) else: raise ValueError("loop variant unhandled") @@ -117,10 +117,10 @@ 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, @@ -130,14 +130,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: @@ -158,7 +158,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(). @@ -218,7 +218,7 @@ class WarnTests(unittest.TestCase): self.module.warn(ob) # Don't directly compare objects since # ``Warning() != Warning()``. - self.assertEquals(str(w[-1].message), str(UserWarning(ob))) + self.assertEqual(str(w[-1].message), str(UserWarning(ob))) def test_filename(self): with warnings_state(self.module): @@ -449,7 +449,7 @@ 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__ = {} @@ -460,7 +460,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 37ec2bc..f898bf7 100644 --- a/Lib/test/test_winreg.py +++ b/Lib/test/test_winreg.py @@ -64,12 +64,12 @@ class WinregTests(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), - "Not the correct number of values") + self.assertEqual(nkeys, 0, "Not the correct number of sub keys") + self.assertEqual(nvalues, len(test_data), + "Not the correct number of values") # Close this key this way... # (but before we do, copy the key as an integer - this allows # us to test that the key really gets closed). @@ -94,8 +94,8 @@ class WinregTests(unittest.TestCase): def ReadTestData(self, root_key, subkeystr="sub_key"): # Check we can get default value for this key. val = QueryValue(root_key, test_key_name) - self.assertEquals(val, "Default value", - "Registry didn't give back the correct value") + self.assertEqual(val, "Default value", + "Registry didn't give back the correct value") key = OpenKey(root_key, test_key_name) # Read the sub-keys @@ -107,22 +107,22 @@ class WinregTests(unittest.TestCase): data = EnumValue(sub_key, index) except EnvironmentError: break - self.assertEquals(data in test_data, True, - "Didn't read back the correct test data") + self.assertEqual(data in test_data, True, + "Didn't read back the correct test data") index = index + 1 - self.assertEquals(index, len(test_data), - "Didn't read the correct number of items") + self.assertEqual(index, len(test_data), + "Didn't read the correct number of items") # Check I can directly access each item for value_name, value_data, value_type in test_data: read_val, read_typ = QueryValueEx(sub_key, value_name) - self.assertEquals(read_val, value_data, - "Could not directly read the value") - self.assertEquals(read_typ, value_type, - "Could not directly read the value") + self.assertEqual(read_val, value_data, + "Could not directly read the value") + self.assertEqual(read_typ, value_type, + "Could not directly read the value") sub_key.Close() # Enumerate our main key. read_val = EnumKey(key, 0) - self.assertEquals(read_val, subkeystr, "Read subkey value wrong") + self.assertEqual(read_val, subkeystr, "Read subkey value wrong") try: EnumKey(key, 1) self.fail("Was able to get a second key when I only have one!") @@ -141,8 +141,8 @@ class WinregTests(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, subkeystr) diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py index ae2fa4d..66ff3b2 100644 --- a/Lib/test/test_with.py +++ b/Lib/test/test_with.py @@ -726,10 +726,10 @@ 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_xmlrpc.py b/Lib/test/test_xmlrpc.py index c864940..9833f26 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -33,7 +33,7 @@ class XMLRPCTestCase(unittest.TestCase): def test_dump_load(self): dump = xmlrpclib.dumps((alist,)) load = xmlrpclib.loads(dump) - self.assertEquals(alist, load[0][0]) + self.assertEqual(alist, load[0][0]) def test_dump_bare_datetime(self): # This checks that an unwrapped datetime.date object can be handled @@ -43,22 +43,22 @@ class XMLRPCTestCase(unittest.TestCase): dt = datetime.datetime(2005, 2, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEquals(newdt, dt) - self.assertEquals(m, None) + self.assertEqual(newdt, dt) + self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23')) + self.assertEqual(newdt, xmlrpclib.DateTime('20050210T11:41:23')) def test_datetime_before_1900(self): # same as before but with a date before 1900 dt = datetime.datetime(1, 2, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEquals(newdt, dt) - self.assertEquals(m, None) + self.assertEqual(newdt, dt) + self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEquals(newdt, xmlrpclib.DateTime('00010210T11:41:23')) + self.assertEqual(newdt, xmlrpclib.DateTime('00010210T11:41:23')) def test_cmp_datetime_DateTime(self): now = datetime.datetime.now() @@ -86,7 +86,7 @@ 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, (2**99,)) @@ -132,14 +132,14 @@ class XMLRPCTestCase(unittest.TestCase): value = alist + [None] arg1 = (alist + [None],) strg = xmlrpclib.dumps(arg1, allow_none=True) - self.assertEquals(value, + self.assertEqual(value, xmlrpclib.loads(strg)[0][0]) self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) def test_get_host_info(self): # see bug #3613, this raised a TypeError transp = xmlrpc.client.Transport() - self.assertEquals(transp.get_host_info("user@host.tld"), + self.assertEqual(transp.get_host_info("user@host.tld"), ('host.tld', [('Authorization', 'Basic dXNlcg==')], {})) @@ -173,8 +173,8 @@ 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) @@ -648,7 +648,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_zipfile.py b/Lib/test/test_zipfile.py index 0e67dbd..e32d2d0 100644 --- a/Lib/test/test_zipfile.py +++ b/Lib/test/test_zipfile.py @@ -55,20 +55,20 @@ class TestsWithSourceFile(unittest.TestCase): directory = fp.getvalue() lines = directory.splitlines() - self.assertEquals(len(lines), 4) # Number of files + header + self.assertEqual(len(lines), 4) # Number of files + header self.assertTrue('File Name' in lines[0]) self.assertTrue('Modified' in lines[0]) self.assertTrue('Size' in lines[0]) fn, date, time, size = lines[1].split() - self.assertEquals(fn, 'another.name') + self.assertEqual(fn, 'another.name') # XXX: timestamp is not tested - self.assertEquals(size, str(len(self.data))) + self.assertEqual(size, str(len(self.data))) # Check the namelist names = zipfp.namelist() - self.assertEquals(len(names), 3) + self.assertEqual(len(names), 3) self.assertTrue(TESTFN in names) self.assertTrue("another.name" in names) self.assertTrue("strfile" in names) @@ -76,18 +76,18 @@ class TestsWithSourceFile(unittest.TestCase): # Check infolist infos = zipfp.infolist() names = [ i.filename for i in infos ] - self.assertEquals(len(names), 3) + self.assertEqual(len(names), 3) self.assertTrue(TESTFN in names) self.assertTrue("another.name" in names) self.assertTrue("strfile" in names) for i in infos: - self.assertEquals(i.file_size, len(self.data)) + self.assertEqual(i.file_size, len(self.data)) # check getinfo for nm in (TESTFN, "another.name", "strfile"): info = zipfp.getinfo(nm) - self.assertEquals(info.filename, nm) - self.assertEquals(info.file_size, len(self.data)) + self.assertEqual(info.filename, nm) + self.assertEqual(info.file_size, len(self.data)) # Check that testzip doesn't raise an exception zipfp.testzip() @@ -445,20 +445,20 @@ class TestZip64InSmallFiles(unittest.TestCase): directory = fp.getvalue() lines = directory.splitlines() - self.assertEquals(len(lines), 4) # Number of files + header + self.assertEqual(len(lines), 4) # Number of files + header self.assertTrue('File Name' in lines[0]) self.assertTrue('Modified' in lines[0]) self.assertTrue('Size' in lines[0]) fn, date, time, size = lines[1].split() - self.assertEquals(fn, 'another.name') + self.assertEqual(fn, 'another.name') # XXX: timestamp is not tested - self.assertEquals(size, str(len(self.data))) + self.assertEqual(size, str(len(self.data))) # Check the namelist names = zipfp.namelist() - self.assertEquals(len(names), 3) + self.assertEqual(len(names), 3) self.assertTrue(TESTFN in names) self.assertTrue("another.name" in names) self.assertTrue("strfile" in names) @@ -466,18 +466,18 @@ class TestZip64InSmallFiles(unittest.TestCase): # Check infolist infos = zipfp.infolist() names = [ i.filename for i in infos ] - self.assertEquals(len(names), 3) + self.assertEqual(len(names), 3) self.assertTrue(TESTFN in names) self.assertTrue("another.name" in names) self.assertTrue("strfile" in names) for i in infos: - self.assertEquals(i.file_size, len(self.data)) + self.assertEqual(i.file_size, len(self.data)) # check getinfo for nm in (TESTFN, "another.name", "strfile"): info = zipfp.getinfo(nm) - self.assertEquals(info.filename, nm) - self.assertEquals(info.file_size, len(self.data)) + self.assertEqual(info.filename, nm) + self.assertEqual(info.file_size, len(self.data)) # Check that testzip doesn't raise an exception zipfp.testzip() @@ -962,9 +962,9 @@ class DecryptionTests(unittest.TestCase): def testGoodPassword(self): self.zip.setpassword(b"python") - self.assertEquals(self.zip.read("test.txt"), self.plain) + self.assertEqual(self.zip.read("test.txt"), self.plain) self.zip2.setpassword(b"12345") - self.assertEquals(self.zip2.read("zero"), self.plain2) + self.assertEqual(self.zip2.read("zero"), self.plain2) class TestsWithRandomBinaryFiles(unittest.TestCase): diff --git a/Lib/test/test_zipimport.py b/Lib/test/test_zipimport.py index 5d163c7..ebf6ad4 100644 --- a/Lib/test/test_zipimport.py +++ b/Lib/test/test_zipimport.py @@ -96,8 +96,8 @@ 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) @@ -209,31 +209,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) pkg = __import__(mod_name) mod = sys.modules[mod_name] - self.assertEquals(zi.get_source(TESTPACK), None) - self.assertEquals(zi.get_source(mod_path), None) - self.assertEquals(zi.get_filename(mod_path), mod.__file__) + self.assertEqual(zi.get_source(TESTPACK), None) + self.assertEqual(zi.get_source(mod_path), None) + self.assertEqual(zi.get_filename(mod_path), mod.__file__) # To pass in the module name instead of the path, we must use the right importer loader = mod.__loader__ - self.assertEquals(loader.get_source(mod_name), None) - self.assertEquals(loader.get_filename(mod_name), mod.__file__) + self.assertEqual(loader.get_source(mod_name), None) + self.assertEqual(loader.get_filename(mod_name), mod.__file__) # test prefix and archivepath members zi2 = zipimport.zipimporter(TEMP_ZIP + os.sep + TESTPACK) - self.assertEquals(zi2.archive, TEMP_ZIP) - self.assertEquals(zi2.prefix, TESTPACK + os.sep) + self.assertEqual(zi2.archive, TEMP_ZIP) + self.assertEqual(zi2.prefix, TESTPACK + os.sep) finally: z.close() os.remove(TEMP_ZIP) @@ -253,26 +253,26 @@ 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) pkg = __import__(mod_name) mod = sys.modules[mod_name] - self.assertEquals(zi.get_source(TESTPACK2), None) - self.assertEquals(zi.get_source(mod_path), None) - self.assertEquals(zi.get_filename(mod_path), mod.__file__) + self.assertEqual(zi.get_source(TESTPACK2), None) + self.assertEqual(zi.get_source(mod_path), None) + self.assertEqual(zi.get_filename(mod_path), mod.__file__) # To pass in the module name instead of the path, we must use the right importer loader = mod.__loader__ - self.assertEquals(loader.get_source(mod_name), None) - self.assertEquals(loader.get_filename(mod_name), mod.__file__) + self.assertEqual(loader.get_source(mod_name), None) + self.assertEqual(loader.get_filename(mod_name), mod.__file__) finally: z.close() os.remove(TEMP_ZIP) @@ -286,7 +286,7 @@ 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.assertTrue('zipimporter object' in repr(zi)) finally: z.close() |