From 2623a37852153363335956afab010cb0beb7e74e Mon Sep 17 00:00:00 2001 From: Ezio Melotti Date: Sun, 21 Nov 2010 13:34:58 +0000 Subject: 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. ........ --- Lib/bsddb/test/test_associate.py | 8 +- Lib/bsddb/test/test_basics.py | 12 +- Lib/bsddb/test/test_compat.py | 2 +- Lib/bsddb/test/test_cursor_pget_bug.py | 10 +- Lib/bsddb/test/test_dbshelve.py | 2 +- Lib/bsddb/test/test_dbtables.py | 4 +- Lib/bsddb/test/test_distributed_transactions.py | 12 +- Lib/bsddb/test/test_early_close.py | 2 +- Lib/bsddb/test/test_fileid.py | 4 +- Lib/bsddb/test/test_get_none.py | 2 +- Lib/bsddb/test/test_join.py | 2 +- Lib/bsddb/test/test_misc.py | 6 +- Lib/bsddb/test/test_recno.py | 2 +- Lib/bsddb/test/test_replication.py | 48 +-- Lib/bsddb/test/test_sequence.py | 60 +-- Lib/ctypes/test/test_keeprefs.py | 36 +- Lib/distutils/tests/test_archive_util.py | 18 +- Lib/distutils/tests/test_bdist.py | 4 +- Lib/distutils/tests/test_bdist_dumb.py | 8 +- Lib/distutils/tests/test_build.py | 14 +- Lib/distutils/tests/test_build_clib.py | 10 +- Lib/distutils/tests/test_build_ext.py | 86 ++--- Lib/distutils/tests/test_ccompiler.py | 8 +- Lib/distutils/tests/test_check.py | 14 +- Lib/distutils/tests/test_cmd.py | 10 +- Lib/distutils/tests/test_config.py | 6 +- Lib/distutils/tests/test_config_cmd.py | 12 +- Lib/distutils/tests/test_core.py | 4 +- Lib/distutils/tests/test_dep_util.py | 4 +- Lib/distutils/tests/test_dir_util.py | 22 +- Lib/distutils/tests/test_dist.py | 42 +- Lib/distutils/tests/test_file_util.py | 8 +- Lib/distutils/tests/test_filelist.py | 20 +- Lib/distutils/tests/test_install_data.py | 8 +- Lib/distutils/tests/test_install_headers.py | 4 +- Lib/distutils/tests/test_install_lib.py | 8 +- Lib/distutils/tests/test_msvc9compiler.py | 4 +- Lib/distutils/tests/test_register.py | 12 +- Lib/distutils/tests/test_sdist.py | 40 +- Lib/distutils/tests/test_spawn.py | 2 +- Lib/distutils/tests/test_sysconfig.py | 10 +- Lib/distutils/tests/test_text_file.py | 2 +- Lib/distutils/tests/test_upload.py | 14 +- Lib/distutils/tests/test_version.py | 20 +- Lib/email/test/test_email.py | 60 +-- Lib/email/test/test_email_renamed.py | 60 +-- Lib/json/tests/test_decode.py | 6 +- Lib/json/tests/test_default.py | 2 +- Lib/json/tests/test_dump.py | 8 +- Lib/json/tests/test_encode_basestring_ascii.py | 2 +- Lib/json/tests/test_float.py | 14 +- Lib/json/tests/test_indent.py | 6 +- Lib/json/tests/test_pass1.py | 2 +- Lib/json/tests/test_pass2.py | 2 +- Lib/json/tests/test_pass3.py | 2 +- Lib/json/tests/test_recursion.py | 2 +- Lib/json/tests/test_scanstring.py | 44 +-- Lib/json/tests/test_separators.py | 6 +- Lib/json/tests/test_speedups.py | 4 +- Lib/json/tests/test_unicode.py | 32 +- Lib/sqlite3/test/dbapi.py | 4 +- Lib/sqlite3/test/types.py | 2 +- Lib/test/buffer_tests.py | 48 +-- Lib/test/fork_wait.py | 6 +- Lib/test/list_tests.py | 4 +- Lib/test/seq_tests.py | 6 +- Lib/test/string_tests.py | 22 +- Lib/test/test_SimpleHTTPServer.py | 10 +- Lib/test/test__locale.py | 8 +- Lib/test/test_argparse.py | 18 +- Lib/test/test_array.py | 4 +- Lib/test/test_ast.py | 20 +- Lib/test/test_augassign.py | 24 +- Lib/test/test_bigaddrspace.py | 2 +- Lib/test/test_bigmem.py | 492 ++++++++++++------------ Lib/test/test_builtin.py | 14 +- Lib/test/test_bytes.py | 26 +- Lib/test/test_cfgparser.py | 16 +- Lib/test/test_cgi.py | 4 +- Lib/test/test_charmapcodec.py | 28 +- Lib/test/test_class.py | 32 +- Lib/test/test_code.py | 6 +- Lib/test/test_codeccallbacks.py | 62 +-- Lib/test/test_codecs.py | 138 +++---- Lib/test/test_codeop.py | 26 +- Lib/test/test_coercion.py | 22 +- Lib/test/test_collections.py | 14 +- Lib/test/test_commands.py | 6 +- Lib/test/test_compiler.py | 46 +-- Lib/test/test_complex.py | 4 +- Lib/test/test_cookielib.py | 262 ++++++------- Lib/test/test_copy_reg.py | 12 +- Lib/test/test_datetime.py | 6 +- Lib/test/test_deque.py | 2 +- Lib/test/test_descr.py | 8 +- Lib/test/test_dircache.py | 6 +- Lib/test/test_epoll.py | 8 +- Lib/test/test_exceptions.py | 28 +- Lib/test/test_file.py | 14 +- Lib/test/test_file2k.py | 16 +- Lib/test/test_fileio.py | 62 +-- Lib/test/test_float.py | 16 +- Lib/test/test_fpformat.py | 14 +- Lib/test/test_fractions.py | 192 ++++----- Lib/test/test_frozen.py | 4 +- Lib/test/test_functools.py | 60 +-- Lib/test/test_gdb.py | 79 ++-- Lib/test/test_getargs2.py | 16 +- Lib/test/test_getopt.py | 4 +- Lib/test/test_glob.py | 4 +- Lib/test/test_gzip.py | 4 +- Lib/test/test_htmllib.py | 18 +- Lib/test/test_httplib.py | 24 +- Lib/test/test_imaplib.py | 2 +- Lib/test/test_inspect.py | 4 +- Lib/test/test_int.py | 2 +- Lib/test/test_io.py | 328 ++++++++-------- Lib/test/test_ioctl.py | 2 +- Lib/test/test_itertools.py | 22 +- Lib/test/test_kqueue.py | 10 +- Lib/test/test_linecache.py | 24 +- Lib/test/test_linuxaudiodev.py | 16 +- Lib/test/test_logging.py | 12 +- Lib/test/test_long.py | 6 +- Lib/test/test_macos.py | 18 +- Lib/test/test_marshal.py | 4 +- Lib/test/test_math.py | 124 +++--- Lib/test/test_memoryio.py | 26 +- Lib/test/test_memoryview.py | 50 +-- Lib/test/test_mhlib.py | 10 +- Lib/test/test_minidom.py | 6 +- Lib/test/test_mmap.py | 30 +- Lib/test/test_multiprocessing.py | 24 +- Lib/test/test_opcodes.py | 16 +- Lib/test/test_operator.py | 6 +- Lib/test/test_optparse.py | 10 +- Lib/test/test_os.py | 18 +- Lib/test/test_parser.py | 8 +- Lib/test/test_pep247.py | 12 +- Lib/test/test_platform.py | 12 +- Lib/test/test_popen2.py | 10 +- Lib/test/test_posix.py | 2 +- Lib/test/test_pow.py | 44 +-- Lib/test/test_pty.py | 8 +- Lib/test/test_py3kwarn.py | 2 +- Lib/test/test_pyclbr.py | 4 +- Lib/test/test_pyexpat.py | 196 +++++----- Lib/test/test_queue.py | 8 +- Lib/test/test_repr.py | 24 +- Lib/test/test_sax.py | 224 +++++------ Lib/test/test_scope.py | 2 +- Lib/test/test_shutil.py | 8 +- Lib/test/test_signal.py | 12 +- Lib/test/test_site.py | 18 +- Lib/test/test_slice.py | 2 +- Lib/test/test_socket.py | 62 +-- Lib/test/test_socketserver.py | 10 +- Lib/test/test_strop.py | 4 +- Lib/test/test_structmembers.py | 40 +- Lib/test/test_sys.py | 12 +- Lib/test/test_sysconfig.py | 36 +- Lib/test/test_tcl.py | 2 +- Lib/test/test_textwrap.py | 34 +- Lib/test/test_threadedtempfile.py | 4 +- Lib/test/test_threading.py | 12 +- Lib/test/test_time.py | 2 +- Lib/test/test_trace.py | 2 +- Lib/test/test_traceback.py | 4 +- Lib/test/test_unicodedata.py | 2 +- Lib/test/test_urllib.py | 2 +- Lib/test/test_urllib2.py | 4 +- Lib/test/test_urllib2_localnet.py | 16 +- Lib/test/test_userstring.py | 4 +- Lib/test/test_warnings.py | 22 +- Lib/test/test_winreg.py | 34 +- Lib/test/test_with.py | 8 +- Lib/test/test_xmllib.py | 4 +- Lib/test/test_xmlrpc.py | 36 +- Lib/test/test_xrange.py | 4 +- Lib/test/test_zipimport.py | 54 +-- Lib/unittest/case.py | 12 +- Lib/unittest/test/test_assertions.py | 8 +- Lib/unittest/test/test_loader.py | 4 +- Misc/NEWS | 5 + 184 files changed, 2331 insertions(+), 2329 deletions(-) diff --git a/Lib/bsddb/test/test_associate.py b/Lib/bsddb/test/test_associate.py index 6f240a0..7a49e11 100644 --- a/Lib/bsddb/test/test_associate.py +++ b/Lib/bsddb/test/test_associate.py @@ -233,7 +233,7 @@ class AssociateTestCase(unittest.TestCase): self.assertEqual(vals, None, vals) vals = secDB.pget('Unknown', txn=txn) - self.assert_(vals[0] == 99 or vals[0] == '99', vals) + self.assertTrue(vals[0] == 99 or vals[0] == '99', vals) vals[1].index('Unknown') vals[1].index('Unnamed') vals[1].index('unknown') @@ -245,9 +245,9 @@ class AssociateTestCase(unittest.TestCase): rec = self.cur.first() while rec is not None: if type(self.keytype) == type(''): - self.assert_(int(rec[0])) # for primary db, key is a number + self.assertTrue(int(rec[0])) # for primary db, key is a number else: - self.assert_(rec[0] and type(rec[0]) == type(0)) + self.assertTrue(rec[0] and type(rec[0]) == type(0)) count = count + 1 if verbose: print rec @@ -262,7 +262,7 @@ class AssociateTestCase(unittest.TestCase): # test cursor pget vals = self.cur.pget('Unknown', flags=db.DB_LAST) - self.assert_(vals[1] == 99 or vals[1] == '99', vals) + self.assertTrue(vals[1] == 99 or vals[1] == '99', vals) self.assertEqual(vals[0], 'Unknown') vals[2].index('Unknown') vals[2].index('Unnamed') diff --git a/Lib/bsddb/test/test_basics.py b/Lib/bsddb/test/test_basics.py index 8b05c61..4d43390 100644 --- a/Lib/bsddb/test/test_basics.py +++ b/Lib/bsddb/test/test_basics.py @@ -612,7 +612,7 @@ class BasicTestCase(unittest.TestCase): d.put("abcde", "ABCDE"); num = d.truncate() - self.assert_(num >= 1, "truncate returned <= 0 on non-empty database") + self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database") num = d.truncate() self.assertEqual(num, 0, "truncate on empty DB returned nonzero (%r)" % (num,)) @@ -631,9 +631,9 @@ class BasicTestCase(unittest.TestCase): if db.version() >= (4, 6): def test08_exists(self) : self.d.put("abcde", "ABCDE") - self.assert_(self.d.exists("abcde") == True, + self.assertTrue(self.d.exists("abcde") == True, "DB->exists() returns wrong value") - self.assert_(self.d.exists("x") == False, + self.assertTrue(self.d.exists("x") == False, "DB->exists() returns wrong value") #---------------------------------------- @@ -806,9 +806,9 @@ class BasicTransactionTestCase(BasicTestCase): self.d.put("abcde", "ABCDE", txn=txn) txn.commit() txn = self.env.txn_begin() - self.assert_(self.d.exists("abcde", txn=txn) == True, + self.assertTrue(self.d.exists("abcde", txn=txn) == True, "DB->exists() returns wrong value") - self.assert_(self.d.exists("x", txn=txn) == False, + self.assertTrue(self.d.exists("x", txn=txn) == False, "DB->exists() returns wrong value") txn.abort() @@ -823,7 +823,7 @@ class BasicTransactionTestCase(BasicTestCase): d.put("abcde", "ABCDE"); txn = self.env.txn_begin() num = d.truncate(txn) - self.assert_(num >= 1, "truncate returned <= 0 on non-empty database") + self.assertTrue(num >= 1, "truncate returned <= 0 on non-empty database") num = d.truncate(txn) self.assertEqual(num, 0, "truncate on empty DB returned nonzero (%r)" % (num,)) diff --git a/Lib/bsddb/test/test_compat.py b/Lib/bsddb/test/test_compat.py index 0b0fa70..7679f19 100644 --- a/Lib/bsddb/test/test_compat.py +++ b/Lib/bsddb/test/test_compat.py @@ -119,7 +119,7 @@ class CompatibilityTestCase(unittest.TestCase): if verbose: print rec - self.assert_(f.has_key('f'), 'Error, missing key!') + self.assertTrue(f.has_key('f'), 'Error, missing key!') # test that set_location() returns the next nearest key, value # on btree databases and raises KeyError on others. diff --git a/Lib/bsddb/test/test_cursor_pget_bug.py b/Lib/bsddb/test/test_cursor_pget_bug.py index 68b6a87..22d3dc1 100644 --- a/Lib/bsddb/test/test_cursor_pget_bug.py +++ b/Lib/bsddb/test/test_cursor_pget_bug.py @@ -37,12 +37,12 @@ class pget_bugTestCase(unittest.TestCase): def test_pget(self): cursor = self.secondary_db.cursor() - self.assertEquals(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET)) - self.assertEquals(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP)) - self.assertEquals(None, cursor.pget(db.DB_NEXT_DUP)) + self.assertEqual(('eggs', 'salad', 'eggs'), cursor.pget(key='eggs', flags=db.DB_SET)) + self.assertEqual(('eggs', 'omelet', 'eggs'), cursor.pget(db.DB_NEXT_DUP)) + self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP)) - self.assertEquals(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET)) - self.assertEquals(None, cursor.pget(db.DB_NEXT_DUP)) + self.assertEqual(('ham', 'spam', 'ham'), cursor.pget('ham', 'spam', flags=db.DB_SET)) + self.assertEqual(None, cursor.pget(db.DB_NEXT_DUP)) cursor.close() diff --git a/Lib/bsddb/test/test_dbshelve.py b/Lib/bsddb/test/test_dbshelve.py index 7ad1fd1..c0135fe 100644 --- a/Lib/bsddb/test/test_dbshelve.py +++ b/Lib/bsddb/test/test_dbshelve.py @@ -255,7 +255,7 @@ class DBShelveTestCase(unittest.TestCase): self.assertEqual(value.L, [x] * 10) else: - self.assert_(0, 'Unknown key type, fix the test') + self.assertTrue(0, 'Unknown key type, fix the test') #---------------------------------------------------------------------- diff --git a/Lib/bsddb/test/test_dbtables.py b/Lib/bsddb/test/test_dbtables.py index c6ecc13..bb31381 100644 --- a/Lib/bsddb/test/test_dbtables.py +++ b/Lib/bsddb/test/test_dbtables.py @@ -84,8 +84,8 @@ class TableDBTestCase(unittest.TestCase): colval = pickle.loads(values[0][colname]) else : colval = pickle.loads(bytes(values[0][colname], "iso8859-1")) - self.assert_(colval > 3.141) - self.assert_(colval < 3.142) + self.assertTrue(colval > 3.141) + self.assertTrue(colval < 3.142) def test02(self): diff --git a/Lib/bsddb/test/test_distributed_transactions.py b/Lib/bsddb/test/test_distributed_transactions.py index a36bd66..1711fc5 100644 --- a/Lib/bsddb/test/test_distributed_transactions.py +++ b/Lib/bsddb/test/test_distributed_transactions.py @@ -88,9 +88,9 @@ class DBTxn_distributed(unittest.TestCase): # Get "to be recovered" transactions but # let them be garbage collected. recovered_txns=self.dbenv.txn_recover() - self.assertEquals(self.num_txns,len(recovered_txns)) + self.assertEqual(self.num_txns,len(recovered_txns)) for gid,txn in recovered_txns : - self.assert_(gid in txns) + self.assertTrue(gid in txns) del txn del recovered_txns @@ -99,7 +99,7 @@ class DBTxn_distributed(unittest.TestCase): # Get "to be recovered" transactions. Commit, abort and # discard them. recovered_txns=self.dbenv.txn_recover() - self.assertEquals(self.num_txns,len(recovered_txns)) + self.assertEqual(self.num_txns,len(recovered_txns)) discard_txns=set() committed_txns=set() state=0 @@ -122,7 +122,7 @@ class DBTxn_distributed(unittest.TestCase): # Verify the discarded transactions are still # around, and dispose them. recovered_txns=self.dbenv.txn_recover() - self.assertEquals(len(discard_txns),len(recovered_txns)) + self.assertEqual(len(discard_txns),len(recovered_txns)) for gid,txn in recovered_txns : txn.abort() del txn @@ -133,8 +133,8 @@ class DBTxn_distributed(unittest.TestCase): # Be sure there are not pending transactions. # Check also database size. recovered_txns=self.dbenv.txn_recover() - self.assert_(len(recovered_txns)==0) - self.assertEquals(len(committed_txns),self.db.stat()["nkeys"]) + self.assertTrue(len(recovered_txns)==0) + self.assertEqual(len(committed_txns),self.db.stat()["nkeys"]) class DBTxn_distributedSYNC(DBTxn_distributed): nosync=False diff --git a/Lib/bsddb/test/test_early_close.py b/Lib/bsddb/test/test_early_close.py index e0c1e1d..86b86dc 100644 --- a/Lib/bsddb/test/test_early_close.py +++ b/Lib/bsddb/test/test_early_close.py @@ -162,7 +162,7 @@ class DBEnvClosedEarlyCrash(unittest.TestCase): txn = dbenv.txn_begin() c1 = d.cursor(txn) c2 = c1.dup() - self.assertEquals(("XXX", "yyy"), c1.first()) + self.assertEqual(("XXX", "yyy"), c1.first()) # Not interested in warnings about implicit close. import warnings diff --git a/Lib/bsddb/test/test_fileid.py b/Lib/bsddb/test/test_fileid.py index 2df2382..095ec83 100644 --- a/Lib/bsddb/test/test_fileid.py +++ b/Lib/bsddb/test/test_fileid.py @@ -35,11 +35,11 @@ class FileidResetTestCase(unittest.TestCase): self.db1 = db.DB(self.db_env) self.db1.open(self.db_path_1, dbtype=db.DB_HASH, flags=db.DB_RDONLY) - self.assertEquals(self.db1.get('spam'), 'eggs') + self.assertEqual(self.db1.get('spam'), 'eggs') self.db2 = db.DB(self.db_env) self.db2.open(self.db_path_2, dbtype=db.DB_HASH, flags=db.DB_RDONLY) - self.assertEquals(self.db2.get('spam'), 'spam') + self.assertEqual(self.db2.get('spam'), 'spam') self.db1.close() self.db2.close() diff --git a/Lib/bsddb/test/test_get_none.py b/Lib/bsddb/test/test_get_none.py index 4aaf2fd..8763b54 100644 --- a/Lib/bsddb/test/test_get_none.py +++ b/Lib/bsddb/test/test_get_none.py @@ -76,7 +76,7 @@ class GetReturnsNoneTestCase(unittest.TestCase): break self.assertNotEqual(rec, None) - self.assert_(exceptionHappened) + self.assertTrue(exceptionHappened) self.assertEqual(count, len(string.letters)) c.close() diff --git a/Lib/bsddb/test/test_join.py b/Lib/bsddb/test/test_join.py index 9b45df8..1f0dfff 100644 --- a/Lib/bsddb/test/test_join.py +++ b/Lib/bsddb/test/test_join.py @@ -67,7 +67,7 @@ class JoinTestCase(unittest.TestCase): # Don't do the .set() in an assert, or you can get a bogus failure # when running python -O tmp = sCursor.set('red') - self.assert_(tmp) + self.assertTrue(tmp) # FIXME: jCursor doesn't properly hold a reference to its # cursors, if they are closed before jcursor is used it diff --git a/Lib/bsddb/test/test_misc.py b/Lib/bsddb/test/test_misc.py index 7b111a8..8dda296 100644 --- a/Lib/bsddb/test/test_misc.py +++ b/Lib/bsddb/test/test_misc.py @@ -32,7 +32,7 @@ class MiscTestCase(unittest.TestCase): def test02_db_home(self): env = db.DBEnv() # check for crash fixed when db_home is used before open() - self.assert_(env.db_home is None) + self.assertTrue(env.db_home is None) env.open(self.homeDir, db.DB_CREATE) if sys.version_info[0] < 3 : self.assertEqual(self.homeDir, env.db_home) @@ -43,7 +43,7 @@ class MiscTestCase(unittest.TestCase): db = hashopen(self.filename) db.close() rp = repr(db) - self.assertEquals(rp, "{}") + self.assertEqual(rp, "{}") def test04_repr_db(self) : db = hashopen(self.filename) @@ -54,7 +54,7 @@ class MiscTestCase(unittest.TestCase): db.close() db = hashopen(self.filename) rp = repr(db) - self.assertEquals(rp, repr(d)) + self.assertEqual(rp, repr(d)) db.close() # http://sourceforge.net/tracker/index.php?func=detail&aid=1708868&group_id=13900&atid=313900 diff --git a/Lib/bsddb/test/test_recno.py b/Lib/bsddb/test/test_recno.py index f86a28b..3191fdc 100644 --- a/Lib/bsddb/test/test_recno.py +++ b/Lib/bsddb/test/test_recno.py @@ -18,7 +18,7 @@ class SimpleRecnoTestCase(unittest.TestCase): def assertFalse(self, expr, msg=None) : return self.failIf(expr,msg=msg) def assertTrue(self, expr, msg=None) : - return self.assert_(expr, msg=msg) + return self.assertTrue(expr, msg=msg) if (sys.version_info < (2, 7)) or ((sys.version_info >= (3, 0)) and (sys.version_info < (3, 2))) : diff --git a/Lib/bsddb/test/test_replication.py b/Lib/bsddb/test/test_replication.py index 9ed2126..f3e974f 100644 --- a/Lib/bsddb/test/test_replication.py +++ b/Lib/bsddb/test/test_replication.py @@ -88,23 +88,23 @@ class DBReplicationManager(DBReplication) : self.dbenvMaster.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100123) self.dbenvClient.rep_set_timeout(db.DB_REP_CONNECTION_RETRY,100321) - self.assertEquals(self.dbenvMaster.rep_get_timeout( + self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_CONNECTION_RETRY), 100123) - self.assertEquals(self.dbenvClient.rep_get_timeout( + self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_CONNECTION_RETRY), 100321) self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100234) self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_TIMEOUT, 100432) - self.assertEquals(self.dbenvMaster.rep_get_timeout( + self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_ELECTION_TIMEOUT), 100234) - self.assertEquals(self.dbenvClient.rep_get_timeout( + self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_ELECTION_TIMEOUT), 100432) self.dbenvMaster.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100345) self.dbenvClient.rep_set_timeout(db.DB_REP_ELECTION_RETRY, 100543) - self.assertEquals(self.dbenvMaster.rep_get_timeout( + self.assertEqual(self.dbenvMaster.rep_get_timeout( db.DB_REP_ELECTION_RETRY), 100345) - self.assertEquals(self.dbenvClient.rep_get_timeout( + self.assertEqual(self.dbenvClient.rep_get_timeout( db.DB_REP_ELECTION_RETRY), 100543) self.dbenvMaster.repmgr_set_ack_policy(db.DB_REPMGR_ACKS_ALL) @@ -113,13 +113,13 @@ class DBReplicationManager(DBReplication) : self.dbenvMaster.repmgr_start(1, db.DB_REP_MASTER); self.dbenvClient.repmgr_start(1, db.DB_REP_CLIENT); - self.assertEquals(self.dbenvMaster.rep_get_nsites(),2) - self.assertEquals(self.dbenvClient.rep_get_nsites(),2) - self.assertEquals(self.dbenvMaster.rep_get_priority(),10) - self.assertEquals(self.dbenvClient.rep_get_priority(),0) - self.assertEquals(self.dbenvMaster.repmgr_get_ack_policy(), + self.assertEqual(self.dbenvMaster.rep_get_nsites(),2) + self.assertEqual(self.dbenvClient.rep_get_nsites(),2) + self.assertEqual(self.dbenvMaster.rep_get_priority(),10) + self.assertEqual(self.dbenvClient.rep_get_priority(),0) + self.assertEqual(self.dbenvMaster.repmgr_get_ack_policy(), db.DB_REPMGR_ACKS_ALL) - self.assertEquals(self.dbenvClient.repmgr_get_ack_policy(), + self.assertEqual(self.dbenvClient.repmgr_get_ack_policy(), db.DB_REPMGR_ACKS_ALL) # The timeout is necessary in BDB 4.5, since DB_EVENT_REP_STARTUPDONE @@ -143,16 +143,16 @@ class DBReplicationManager(DBReplication) : startup_timeout = True d = self.dbenvMaster.repmgr_site_list() - self.assertEquals(len(d), 1) - self.assertEquals(d[0][0], "127.0.0.1") - self.assertEquals(d[0][1], client_port) + self.assertEqual(len(d), 1) + self.assertEqual(d[0][0], "127.0.0.1") + self.assertEqual(d[0][1], client_port) self.assertTrue((d[0][2]==db.DB_REPMGR_CONNECTED) or \ (d[0][2]==db.DB_REPMGR_DISCONNECTED)) d = self.dbenvClient.repmgr_site_list() - self.assertEquals(len(d), 1) - self.assertEquals(d[0][0], "127.0.0.1") - self.assertEquals(d[0][1], master_port) + self.assertEqual(len(d), 1) + self.assertEqual(d[0][0], "127.0.0.1") + self.assertEqual(d[0][1], master_port) self.assertTrue((d[0][2]==db.DB_REPMGR_CONNECTED) or \ (d[0][2]==db.DB_REPMGR_DISCONNECTED)) @@ -207,7 +207,7 @@ class DBReplicationManager(DBReplication) : self.skipTest("replication test skipped due to random failure, " "see issue 3892") self.assertTrue(time.time()= (4,7) : def test02_test_request(self) : diff --git a/Lib/bsddb/test/test_sequence.py b/Lib/bsddb/test/test_sequence.py index cad598b..3d3ee29 100644 --- a/Lib/bsddb/test/test_sequence.py +++ b/Lib/bsddb/test/test_sequence.py @@ -37,53 +37,53 @@ class DBSequenceTest(unittest.TestCase): self.seq = db.DBSequence(self.d, flags=0) start_value = 10 * self.int_32_max self.assertEqual(0xA00000000, start_value) - self.assertEquals(None, self.seq.initial_value(start_value)) - self.assertEquals(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) - self.assertEquals(start_value, self.seq.get(5)) - self.assertEquals(start_value + 5, self.seq.get()) + self.assertEqual(None, self.seq.initial_value(start_value)) + self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) + self.assertEqual(start_value, self.seq.get(5)) + self.assertEqual(start_value + 5, self.seq.get()) def test_remove(self): self.seq = db.DBSequence(self.d, flags=0) - self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) - self.assertEquals(None, self.seq.remove(txn=None, flags=0)) + self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) + self.assertEqual(None, self.seq.remove(txn=None, flags=0)) del self.seq def test_get_key(self): self.seq = db.DBSequence(self.d, flags=0) key = 'foo' - self.assertEquals(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE)) - self.assertEquals(key, self.seq.get_key()) + self.assertEqual(None, self.seq.open(key=key, txn=None, flags=db.DB_CREATE)) + self.assertEqual(key, self.seq.get_key()) def test_get_dbp(self): self.seq = db.DBSequence(self.d, flags=0) - self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) - self.assertEquals(self.d, self.seq.get_dbp()) + self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) + self.assertEqual(self.d, self.seq.get_dbp()) def test_cachesize(self): self.seq = db.DBSequence(self.d, flags=0) cashe_size = 10 - self.assertEquals(None, self.seq.set_cachesize(cashe_size)) - self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) - self.assertEquals(cashe_size, self.seq.get_cachesize()) + self.assertEqual(None, self.seq.set_cachesize(cashe_size)) + self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) + self.assertEqual(cashe_size, self.seq.get_cachesize()) def test_flags(self): self.seq = db.DBSequence(self.d, flags=0) flag = db.DB_SEQ_WRAP; - self.assertEquals(None, self.seq.set_flags(flag)) - self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) - self.assertEquals(flag, self.seq.get_flags() & flag) + self.assertEqual(None, self.seq.set_flags(flag)) + self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) + self.assertEqual(flag, self.seq.get_flags() & flag) def test_range(self): self.seq = db.DBSequence(self.d, flags=0) seq_range = (10 * self.int_32_max, 11 * self.int_32_max - 1) - self.assertEquals(None, self.seq.set_range(seq_range)) + self.assertEqual(None, self.seq.set_range(seq_range)) self.seq.initial_value(seq_range[0]) - self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) - self.assertEquals(seq_range, self.seq.get_range()) + self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) + self.assertEqual(seq_range, self.seq.get_range()) def test_stat(self): self.seq = db.DBSequence(self.d, flags=0) - self.assertEquals(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) + self.assertEqual(None, self.seq.open(key='foo', txn=None, flags=db.DB_CREATE)) stat = self.seq.stat() for param in ('nowait', 'min', 'max', 'value', 'current', 'flags', 'cache_size', 'last_value', 'wait'): @@ -106,24 +106,24 @@ class DBSequenceTest(unittest.TestCase): def test_64bits(self) : # We don't use both extremes because they are problematic value_plus=(1L<<63)-2 - self.assertEquals(9223372036854775806L,value_plus) + self.assertEqual(9223372036854775806L,value_plus) value_minus=(-1L<<63)+1 # Two complement - self.assertEquals(-9223372036854775807L,value_minus) + self.assertEqual(-9223372036854775807L,value_minus) self.seq = db.DBSequence(self.d, flags=0) - self.assertEquals(None, self.seq.initial_value(value_plus-1)) - self.assertEquals(None, self.seq.open(key='id', txn=None, + self.assertEqual(None, self.seq.initial_value(value_plus-1)) + self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) - self.assertEquals(value_plus-1, self.seq.get(1)) - self.assertEquals(value_plus, self.seq.get(1)) + self.assertEqual(value_plus-1, self.seq.get(1)) + self.assertEqual(value_plus, self.seq.get(1)) self.seq.remove(txn=None, flags=0) self.seq = db.DBSequence(self.d, flags=0) - self.assertEquals(None, self.seq.initial_value(value_minus)) - self.assertEquals(None, self.seq.open(key='id', txn=None, + self.assertEqual(None, self.seq.initial_value(value_minus)) + self.assertEqual(None, self.seq.open(key='id', txn=None, flags=db.DB_CREATE)) - self.assertEquals(value_minus, self.seq.get(1)) - self.assertEquals(value_minus+1, self.seq.get(1)) + self.assertEqual(value_minus, self.seq.get(1)) + self.assertEqual(value_minus+1, self.seq.get(1)) def test_multiple_close(self): self.seq = db.DBSequence(self.d) diff --git a/Lib/ctypes/test/test_keeprefs.py b/Lib/ctypes/test/test_keeprefs.py index 0955e76..b504c0c 100644 --- a/Lib/ctypes/test/test_keeprefs.py +++ b/Lib/ctypes/test/test_keeprefs.py @@ -4,19 +4,19 @@ import unittest class SimpleTestCase(unittest.TestCase): def test_cint(self): x = c_int() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.value = 42 - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x = c_int(99) - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) def test_ccharp(self): x = c_char_p() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.value = "abc" - self.assertEquals(x._objects, "abc") + self.assertEqual(x._objects, "abc") x = c_char_p("spam") - self.assertEquals(x._objects, "spam") + self.assertEqual(x._objects, "spam") class StructureTestCase(unittest.TestCase): def test_cint_struct(self): @@ -25,21 +25,21 @@ class StructureTestCase(unittest.TestCase): ("b", c_int)] x = X() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.a = 42 x.b = 99 - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) def test_ccharp_struct(self): class X(Structure): _fields_ = [("a", c_char_p), ("b", c_char_p)] x = X() - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.a = "spam" x.b = "foo" - self.assertEquals(x._objects, {"0": "spam", "1": "foo"}) + self.assertEqual(x._objects, {"0": "spam", "1": "foo"}) def test_struct_struct(self): class POINT(Structure): @@ -52,28 +52,28 @@ class StructureTestCase(unittest.TestCase): r.ul.y = 1 r.lr.x = 2 r.lr.y = 3 - self.assertEquals(r._objects, None) + self.assertEqual(r._objects, None) r = RECT() pt = POINT(1, 2) r.ul = pt - self.assertEquals(r._objects, {'0': {}}) + self.assertEqual(r._objects, {'0': {}}) r.ul.x = 22 r.ul.y = 44 - self.assertEquals(r._objects, {'0': {}}) + self.assertEqual(r._objects, {'0': {}}) r.lr = POINT() - self.assertEquals(r._objects, {'0': {}, '1': {}}) + self.assertEqual(r._objects, {'0': {}, '1': {}}) class ArrayTestCase(unittest.TestCase): def test_cint_array(self): INTARR = c_int * 3 ia = INTARR() - self.assertEquals(ia._objects, None) + self.assertEqual(ia._objects, None) ia[0] = 1 ia[1] = 2 ia[2] = 3 - self.assertEquals(ia._objects, None) + self.assertEqual(ia._objects, None) class X(Structure): _fields_ = [("x", c_int), @@ -83,9 +83,9 @@ class ArrayTestCase(unittest.TestCase): x.x = 1000 x.a[0] = 42 x.a[1] = 96 - self.assertEquals(x._objects, None) + self.assertEqual(x._objects, None) x.a = ia - self.assertEquals(x._objects, {'1': {}}) + self.assertEqual(x._objects, {'1': {}}) class PointerTestCase(unittest.TestCase): def test_p_cint(self): diff --git a/Lib/distutils/tests/test_archive_util.py b/Lib/distutils/tests/test_archive_util.py index a9b46d8..bab9157 100644 --- a/Lib/distutils/tests/test_archive_util.py +++ b/Lib/distutils/tests/test_archive_util.py @@ -129,7 +129,7 @@ class ArchiveUtilTestCase(support.TempdirManager, self.assertTrue(os.path.exists(tarball2)) # let's compare both tarballs - self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) + self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2)) # trying an uncompressed one base_name = os.path.join(tmpdir2, 'archive') @@ -169,7 +169,7 @@ class ArchiveUtilTestCase(support.TempdirManager, os.chdir(old_dir) tarball = base_name + '.tar.Z' self.assertTrue(os.path.exists(tarball)) - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) # same test with dry_run os.remove(tarball) @@ -183,7 +183,7 @@ class ArchiveUtilTestCase(support.TempdirManager, finally: os.chdir(old_dir) self.assertTrue(not os.path.exists(tarball)) - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) @unittest.skipUnless(zlib, "Requires zlib") @unittest.skipUnless(ZIP_SUPPORT, 'Need zip support to run') @@ -201,9 +201,9 @@ class ArchiveUtilTestCase(support.TempdirManager, tarball = base_name + '.zip' def test_check_archive_formats(self): - self.assertEquals(check_archive_formats(['gztar', 'xxx', 'zip']), - 'xxx') - self.assertEquals(check_archive_formats(['gztar', 'zip']), None) + self.assertEqual(check_archive_formats(['gztar', 'xxx', 'zip']), + 'xxx') + self.assertEqual(check_archive_formats(['gztar', 'zip']), None) def test_make_archive(self): tmpdir = self.mkdtemp() @@ -258,8 +258,8 @@ class ArchiveUtilTestCase(support.TempdirManager, archive = tarfile.open(archive_name) try: for member in archive.getmembers(): - self.assertEquals(member.uid, 0) - self.assertEquals(member.gid, 0) + self.assertEqual(member.uid, 0) + self.assertEqual(member.gid, 0) finally: archive.close() @@ -273,7 +273,7 @@ class ArchiveUtilTestCase(support.TempdirManager, make_archive('xxx', 'xxx', root_dir=self.mkdtemp()) except: pass - self.assertEquals(os.getcwd(), current_dir) + self.assertEqual(os.getcwd(), current_dir) finally: del ARCHIVE_FORMATS['xxx'] diff --git a/Lib/distutils/tests/test_bdist.py b/Lib/distutils/tests/test_bdist.py index a37f4a9..fa7cd5a 100644 --- a/Lib/distutils/tests/test_bdist.py +++ b/Lib/distutils/tests/test_bdist.py @@ -25,7 +25,7 @@ class BuildTestCase(support.TempdirManager, cmd = bdist(dist) cmd.formats = ['msi'] cmd.ensure_finalized() - self.assertEquals(cmd.formats, ['msi']) + self.assertEqual(cmd.formats, ['msi']) # what format bdist offers ? # XXX an explicit list in bdist is @@ -36,7 +36,7 @@ class BuildTestCase(support.TempdirManager, formats.sort() founded = cmd.format_command.keys() founded.sort() - self.assertEquals(founded, formats) + self.assertEqual(founded, formats) def test_suite(): return unittest.makeSuite(BuildTestCase) diff --git a/Lib/distutils/tests/test_bdist_dumb.py b/Lib/distutils/tests/test_bdist_dumb.py index f2220f4..5a22a10 100644 --- a/Lib/distutils/tests/test_bdist_dumb.py +++ b/Lib/distutils/tests/test_bdist_dumb.py @@ -78,7 +78,7 @@ class BuildDumbTestCase(support.TempdirManager, base = base.replace(':', '-') wanted = ['%s.zip' % base] - self.assertEquals(dist_created, wanted) + self.assertEqual(dist_created, wanted) # now let's check what we have in the zip file # XXX to be done @@ -87,16 +87,16 @@ class BuildDumbTestCase(support.TempdirManager, pkg_dir, dist = self.create_dist() os.chdir(pkg_dir) cmd = bdist_dumb(dist) - self.assertEquals(cmd.bdist_dir, None) + self.assertEqual(cmd.bdist_dir, None) cmd.finalize_options() # bdist_dir is initialized to bdist_base/dumb if not set base = cmd.get_finalized_command('bdist').bdist_base - self.assertEquals(cmd.bdist_dir, os.path.join(base, 'dumb')) + self.assertEqual(cmd.bdist_dir, os.path.join(base, 'dumb')) # the format is set to a default value depending on the os.name default = cmd.default_format[os.name] - self.assertEquals(cmd.format, default) + self.assertEqual(cmd.format, default) def test_suite(): return unittest.makeSuite(BuildDumbTestCase) diff --git a/Lib/distutils/tests/test_build.py b/Lib/distutils/tests/test_build.py index 2418e16..3db5703 100644 --- a/Lib/distutils/tests/test_build.py +++ b/Lib/distutils/tests/test_build.py @@ -17,11 +17,11 @@ class BuildTestCase(support.TempdirManager, cmd.finalize_options() # if not specified, plat_name gets the current platform - self.assertEquals(cmd.plat_name, get_platform()) + self.assertEqual(cmd.plat_name, get_platform()) # build_purelib is build + lib wanted = os.path.join(cmd.build_base, 'lib') - self.assertEquals(cmd.build_purelib, wanted) + self.assertEqual(cmd.build_purelib, wanted) # build_platlib is 'build/lib.platform-x.x[-pydebug]' # examples: @@ -31,21 +31,21 @@ class BuildTestCase(support.TempdirManager, self.assertTrue(cmd.build_platlib.endswith('-pydebug')) plat_spec += '-pydebug' wanted = os.path.join(cmd.build_base, 'lib' + plat_spec) - self.assertEquals(cmd.build_platlib, wanted) + self.assertEqual(cmd.build_platlib, wanted) # by default, build_lib = build_purelib - self.assertEquals(cmd.build_lib, cmd.build_purelib) + self.assertEqual(cmd.build_lib, cmd.build_purelib) # build_temp is build/temp. wanted = os.path.join(cmd.build_base, 'temp' + plat_spec) - self.assertEquals(cmd.build_temp, wanted) + self.assertEqual(cmd.build_temp, wanted) # build_scripts is build/scripts-x.x wanted = os.path.join(cmd.build_base, 'scripts-' + sys.version[0:3]) - self.assertEquals(cmd.build_scripts, wanted) + self.assertEqual(cmd.build_scripts, wanted) # executable is os.path.normpath(sys.executable) - self.assertEquals(cmd.executable, os.path.normpath(sys.executable)) + self.assertEqual(cmd.executable, os.path.normpath(sys.executable)) def test_suite(): return unittest.makeSuite(BuildTestCase) diff --git a/Lib/distutils/tests/test_build_clib.py b/Lib/distutils/tests/test_build_clib.py index 145eff5..d77912a 100644 --- a/Lib/distutils/tests/test_build_clib.py +++ b/Lib/distutils/tests/test_build_clib.py @@ -55,14 +55,14 @@ class BuildCLibTestCase(support.TempdirManager, self.assertRaises(DistutilsSetupError, cmd.get_source_files) cmd.libraries = [('name', {'sources': ['a', 'b']})] - self.assertEquals(cmd.get_source_files(), ['a', 'b']) + self.assertEqual(cmd.get_source_files(), ['a', 'b']) cmd.libraries = [('name', {'sources': ('a', 'b')})] - self.assertEquals(cmd.get_source_files(), ['a', 'b']) + self.assertEqual(cmd.get_source_files(), ['a', 'b']) cmd.libraries = [('name', {'sources': ('a', 'b')}), ('name2', {'sources': ['c', 'd']})] - self.assertEquals(cmd.get_source_files(), ['a', 'b', 'c', 'd']) + self.assertEqual(cmd.get_source_files(), ['a', 'b', 'c', 'd']) def test_build_libraries(self): @@ -91,11 +91,11 @@ class BuildCLibTestCase(support.TempdirManager, cmd.include_dirs = 'one-dir' cmd.finalize_options() - self.assertEquals(cmd.include_dirs, ['one-dir']) + self.assertEqual(cmd.include_dirs, ['one-dir']) cmd.include_dirs = None cmd.finalize_options() - self.assertEquals(cmd.include_dirs, []) + self.assertEqual(cmd.include_dirs, []) cmd.distribution.libraries = 'WONTWORK' self.assertRaises(DistutilsSetupError, cmd.finalize_options) diff --git a/Lib/distutils/tests/test_build_ext.py b/Lib/distutils/tests/test_build_ext.py index d14c5f6..86568eb 100644 --- a/Lib/distutils/tests/test_build_ext.py +++ b/Lib/distutils/tests/test_build_ext.py @@ -103,15 +103,15 @@ class BuildExtTestCase(support.TempdirManager, import xx for attr in ('error', 'foo', 'new', 'roj'): - self.assert_(hasattr(xx, attr)) + self.assertTrue(hasattr(xx, attr)) - self.assertEquals(xx.foo(2, 5), 7) - self.assertEquals(xx.foo(13,15), 28) - self.assertEquals(xx.new().demo(), None) + self.assertEqual(xx.foo(2, 5), 7) + self.assertEqual(xx.foo(13,15), 28) + self.assertEqual(xx.new().demo(), None) doc = 'This is a template module just for instruction.' - self.assertEquals(xx.__doc__, doc) - self.assert_(isinstance(xx.Null(), xx.Null)) - self.assert_(isinstance(xx.Str(), xx.Str)) + self.assertEqual(xx.__doc__, doc) + self.assertTrue(isinstance(xx.Null(), xx.Null)) + self.assertTrue(isinstance(xx.Str(), xx.Str)) def test_solaris_enable_shared(self): dist = Distribution({'name': 'xx'}) @@ -132,7 +132,7 @@ class BuildExtTestCase(support.TempdirManager, _config_vars['Py_ENABLE_SHARED'] = old_var # make sure we get some library dirs under solaris - self.assert_(len(cmd.library_dirs) > 0) + self.assertTrue(len(cmd.library_dirs) > 0) def test_finalize_options(self): # Make sure Python's include directories (for Python.h, pyconfig.h, @@ -144,31 +144,31 @@ class BuildExtTestCase(support.TempdirManager, from distutils import sysconfig py_include = sysconfig.get_python_inc() - self.assert_(py_include in cmd.include_dirs) + self.assertTrue(py_include in cmd.include_dirs) plat_py_include = sysconfig.get_python_inc(plat_specific=1) - self.assert_(plat_py_include in cmd.include_dirs) + self.assertTrue(plat_py_include in cmd.include_dirs) # make sure cmd.libraries is turned into a list # if it's a string cmd = build_ext(dist) cmd.libraries = 'my_lib' cmd.finalize_options() - self.assertEquals(cmd.libraries, ['my_lib']) + self.assertEqual(cmd.libraries, ['my_lib']) # make sure cmd.library_dirs is turned into a list # if it's a string cmd = build_ext(dist) cmd.library_dirs = 'my_lib_dir' cmd.finalize_options() - self.assert_('my_lib_dir' in cmd.library_dirs) + self.assertTrue('my_lib_dir' in cmd.library_dirs) # make sure rpath is turned into a list # if it's a list of os.pathsep's paths cmd = build_ext(dist) cmd.rpath = os.pathsep.join(['one', 'two']) cmd.finalize_options() - self.assertEquals(cmd.rpath, ['one', 'two']) + self.assertEqual(cmd.rpath, ['one', 'two']) # XXX more tests to perform for win32 @@ -177,25 +177,25 @@ class BuildExtTestCase(support.TempdirManager, cmd = build_ext(dist) cmd.define = 'one,two' cmd.finalize_options() - self.assertEquals(cmd.define, [('one', '1'), ('two', '1')]) + self.assertEqual(cmd.define, [('one', '1'), ('two', '1')]) # make sure undef is turned into a list of # strings if they are ','-separated strings cmd = build_ext(dist) cmd.undef = 'one,two' cmd.finalize_options() - self.assertEquals(cmd.undef, ['one', 'two']) + self.assertEqual(cmd.undef, ['one', 'two']) # make sure swig_opts is turned into a list cmd = build_ext(dist) cmd.swig_opts = None cmd.finalize_options() - self.assertEquals(cmd.swig_opts, []) + self.assertEqual(cmd.swig_opts, []) cmd = build_ext(dist) cmd.swig_opts = '1 2' cmd.finalize_options() - self.assertEquals(cmd.swig_opts, ['1', '2']) + self.assertEqual(cmd.swig_opts, ['1', '2']) def test_check_extensions_list(self): dist = Distribution() @@ -226,13 +226,13 @@ class BuildExtTestCase(support.TempdirManager, 'some': 'bar'})] cmd.check_extensions_list(exts) ext = exts[0] - self.assert_(isinstance(ext, Extension)) + self.assertTrue(isinstance(ext, Extension)) # check_extensions_list adds in ext the values passed # when they are in ('include_dirs', 'library_dirs', 'libraries' # 'extra_objects', 'extra_compile_args', 'extra_link_args') - self.assertEquals(ext.libraries, 'foo') - self.assert_(not hasattr(ext, 'some')) + self.assertEqual(ext.libraries, 'foo') + self.assertTrue(not hasattr(ext, 'some')) # 'macros' element of build info dict must be 1- or 2-tuple exts = [('foo.bar', {'sources': [''], 'libraries': 'foo', @@ -241,15 +241,15 @@ class BuildExtTestCase(support.TempdirManager, exts[0][1]['macros'] = [('1', '2'), ('3',)] cmd.check_extensions_list(exts) - self.assertEquals(exts[0].undef_macros, ['3']) - self.assertEquals(exts[0].define_macros, [('1', '2')]) + self.assertEqual(exts[0].undef_macros, ['3']) + self.assertEqual(exts[0].define_macros, [('1', '2')]) def test_get_source_files(self): modules = [Extension('foo', ['xxx'])] dist = Distribution({'name': 'xx', 'ext_modules': modules}) cmd = build_ext(dist) cmd.ensure_finalized() - self.assertEquals(cmd.get_source_files(), ['xxx']) + self.assertEqual(cmd.get_source_files(), ['xxx']) def test_compiler_option(self): # cmd.compiler is an option and @@ -260,7 +260,7 @@ class BuildExtTestCase(support.TempdirManager, cmd.compiler = 'unix' cmd.ensure_finalized() cmd.run() - self.assertEquals(cmd.compiler, 'unix') + self.assertEqual(cmd.compiler, 'unix') def test_get_outputs(self): tmp_dir = self.mkdtemp() @@ -272,7 +272,7 @@ class BuildExtTestCase(support.TempdirManager, cmd = build_ext(dist) self._fixup_command(cmd) cmd.ensure_finalized() - self.assertEquals(len(cmd.get_outputs()), 1) + self.assertEqual(len(cmd.get_outputs()), 1) if os.name == "nt": cmd.debug = sys.executable.endswith("_d.exe") @@ -291,20 +291,20 @@ class BuildExtTestCase(support.TempdirManager, so_file = cmd.get_outputs()[0] finally: os.chdir(old_wd) - self.assert_(os.path.exists(so_file)) - self.assertEquals(os.path.splitext(so_file)[-1], - sysconfig.get_config_var('SO')) + self.assertTrue(os.path.exists(so_file)) + self.assertEqual(os.path.splitext(so_file)[-1], + sysconfig.get_config_var('SO')) so_dir = os.path.dirname(so_file) - self.assertEquals(so_dir, other_tmp_dir) + self.assertEqual(so_dir, other_tmp_dir) cmd.compiler = None cmd.inplace = 0 cmd.run() so_file = cmd.get_outputs()[0] - self.assert_(os.path.exists(so_file)) - self.assertEquals(os.path.splitext(so_file)[-1], - sysconfig.get_config_var('SO')) + self.assertTrue(os.path.exists(so_file)) + self.assertEqual(os.path.splitext(so_file)[-1], + sysconfig.get_config_var('SO')) so_dir = os.path.dirname(so_file) - self.assertEquals(so_dir, cmd.build_lib) + self.assertEqual(so_dir, cmd.build_lib) # inplace = 0, cmd.package = 'bar' build_py = cmd.get_finalized_command('build_py') @@ -312,7 +312,7 @@ class BuildExtTestCase(support.TempdirManager, path = cmd.get_ext_fullpath('foo') # checking that the last directory is the build_dir path = os.path.split(path)[0] - self.assertEquals(path, cmd.build_lib) + self.assertEqual(path, cmd.build_lib) # inplace = 1, cmd.package = 'bar' cmd.inplace = 1 @@ -326,7 +326,7 @@ class BuildExtTestCase(support.TempdirManager, # checking that the last directory is bar path = os.path.split(path)[0] lastdir = os.path.split(path)[-1] - self.assertEquals(lastdir, 'bar') + self.assertEqual(lastdir, 'bar') def test_ext_fullpath(self): ext = sysconfig.get_config_vars()['SO'] @@ -338,14 +338,14 @@ class BuildExtTestCase(support.TempdirManager, curdir = os.getcwd() wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext) path = cmd.get_ext_fullpath('lxml.etree') - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) # building lxml.etree not inplace cmd.inplace = 0 cmd.build_lib = os.path.join(curdir, 'tmpdir') wanted = os.path.join(curdir, 'tmpdir', 'lxml', 'etree' + ext) path = cmd.get_ext_fullpath('lxml.etree') - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) # building twisted.runner.portmap not inplace build_py = cmd.get_finalized_command('build_py') @@ -354,13 +354,13 @@ class BuildExtTestCase(support.TempdirManager, path = cmd.get_ext_fullpath('twisted.runner.portmap') wanted = os.path.join(curdir, 'tmpdir', 'twisted', 'runner', 'portmap' + ext) - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) # building twisted.runner.portmap inplace cmd.inplace = 1 path = cmd.get_ext_fullpath('twisted.runner.portmap') wanted = os.path.join(curdir, 'twisted', 'runner', 'portmap' + ext) - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) def test_build_ext_inplace(self): etree_c = os.path.join(self.tmp_dir, 'lxml.etree.c') @@ -375,7 +375,7 @@ class BuildExtTestCase(support.TempdirManager, ext = sysconfig.get_config_var("SO") wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext) path = cmd.get_ext_fullpath('lxml.etree') - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) def test_setuptools_compat(self): import distutils.core, distutils.extension, distutils.command.build_ext @@ -400,7 +400,7 @@ class BuildExtTestCase(support.TempdirManager, ext = sysconfig.get_config_var("SO") wanted = os.path.join(curdir, 'src', 'lxml', 'etree' + ext) path = cmd.get_ext_fullpath('lxml.etree') - self.assertEquals(wanted, path) + self.assertEqual(wanted, path) finally: # restoring Distutils' Extension class otherwise its broken distutils.extension.Extension = saved_ext @@ -415,7 +415,7 @@ class BuildExtTestCase(support.TempdirManager, ext_name = os.path.join('UpdateManager', 'fdsend') ext_path = cmd.get_ext_fullpath(ext_name) wanted = os.path.join(cmd.build_lib, 'UpdateManager', 'fdsend' + ext) - self.assertEquals(ext_path, wanted) + self.assertEqual(ext_path, wanted) def test_build_ext_path_cross_platform(self): if sys.platform != 'win32': @@ -428,7 +428,7 @@ class BuildExtTestCase(support.TempdirManager, ext_name = 'UpdateManager/fdsend' ext_path = cmd.get_ext_fullpath(ext_name) wanted = os.path.join(cmd.build_lib, 'UpdateManager', 'fdsend' + ext) - self.assertEquals(ext_path, wanted) + self.assertEqual(ext_path, wanted) def test_suite(): return unittest.makeSuite(BuildExtTestCase) diff --git a/Lib/distutils/tests/test_ccompiler.py b/Lib/distutils/tests/test_ccompiler.py index 317e77f..e21873e 100644 --- a/Lib/distutils/tests/test_ccompiler.py +++ b/Lib/distutils/tests/test_ccompiler.py @@ -32,7 +32,7 @@ class CCompilerTestCase(support.EnvironGuard, unittest.TestCase): opts = gen_lib_options(compiler, libdirs, runlibdirs, libs) wanted = ['-Llib1', '-Llib2', '-cool', '-Rrunlib1', 'found', '-lname2'] - self.assertEquals(opts, wanted) + self.assertEqual(opts, wanted) def test_debug_print(self): @@ -43,14 +43,14 @@ class CCompilerTestCase(support.EnvironGuard, unittest.TestCase): with captured_stdout() as stdout: compiler.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') debug.DEBUG = True try: with captured_stdout() as stdout: compiler.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), 'xxx\n') + self.assertEqual(stdout.read(), 'xxx\n') finally: debug.DEBUG = False @@ -72,7 +72,7 @@ class CCompilerTestCase(support.EnvironGuard, unittest.TestCase): comp = compiler() customize_compiler(comp) - self.assertEquals(comp.exes['archiver'], 'my_ar -arflags') + self.assertEqual(comp.exes['archiver'], 'my_ar -arflags') def test_suite(): return unittest.makeSuite(CCompilerTestCase) diff --git a/Lib/distutils/tests/test_check.py b/Lib/distutils/tests/test_check.py index 372bae3..7c56c04 100644 --- a/Lib/distutils/tests/test_check.py +++ b/Lib/distutils/tests/test_check.py @@ -26,7 +26,7 @@ class CheckTestCase(support.LoggingSilencer, # by default, check is checking the metadata # should have some warnings cmd = self._run() - self.assertEquals(cmd._warnings, 2) + self.assertEqual(cmd._warnings, 2) # now let's add the required fields # and run it again, to make sure we don't get @@ -35,7 +35,7 @@ class CheckTestCase(support.LoggingSilencer, 'author_email': 'xxx', 'name': 'xxx', 'version': 'xxx'} cmd = self._run(metadata) - self.assertEquals(cmd._warnings, 0) + self.assertEqual(cmd._warnings, 0) # now with the strict mode, we should # get an error if there are missing metadata @@ -43,7 +43,7 @@ class CheckTestCase(support.LoggingSilencer, # and of course, no error when all metadata are present cmd = self._run(metadata, strict=1) - self.assertEquals(cmd._warnings, 0) + self.assertEqual(cmd._warnings, 0) def test_check_document(self): if not HAS_DOCUTILS: # won't test without docutils @@ -54,12 +54,12 @@ class CheckTestCase(support.LoggingSilencer, # let's see if it detects broken rest broken_rest = 'title\n===\n\ntest' msgs = cmd._check_rst_data(broken_rest) - self.assertEquals(len(msgs), 1) + self.assertEqual(len(msgs), 1) # and non-broken rest rest = 'title\n=====\n\ntest' msgs = cmd._check_rst_data(rest) - self.assertEquals(len(msgs), 0) + self.assertEqual(len(msgs), 0) def test_check_restructuredtext(self): if not HAS_DOCUTILS: # won't test without docutils @@ -69,7 +69,7 @@ class CheckTestCase(support.LoggingSilencer, pkg_info, dist = self.create_dist(long_description=broken_rest) cmd = check(dist) cmd.check_restructuredtext() - self.assertEquals(cmd._warnings, 1) + self.assertEqual(cmd._warnings, 1) # let's see if we have an error with strict=1 metadata = {'url': 'xxx', 'author': 'xxx', @@ -82,7 +82,7 @@ class CheckTestCase(support.LoggingSilencer, # and non-broken rest metadata['long_description'] = 'title\n=====\n\ntest' cmd = self._run(metadata, strict=1, restructuredtext=1) - self.assertEquals(cmd._warnings, 0) + self.assertEqual(cmd._warnings, 0) def test_check_all(self): diff --git a/Lib/distutils/tests/test_cmd.py b/Lib/distutils/tests/test_cmd.py index cfd6485..97cdb8a 100644 --- a/Lib/distutils/tests/test_cmd.py +++ b/Lib/distutils/tests/test_cmd.py @@ -44,7 +44,7 @@ class CommandTestCase(unittest.TestCase): # making sure execute gets called properly def _execute(func, args, exec_msg, level): - self.assertEquals(exec_msg, 'generating out from in') + self.assertEqual(exec_msg, 'generating out from in') cmd.force = True cmd.execute = _execute cmd.make_file(infiles='in', outfile='out', func='func', args=()) @@ -63,7 +63,7 @@ class CommandTestCase(unittest.TestCase): wanted = ["command options for 'MyCmd':", ' option1 = 1', ' option2 = 1'] - self.assertEquals(msgs, wanted) + self.assertEqual(msgs, wanted) def test_ensure_string(self): cmd = self.cmd @@ -81,7 +81,7 @@ class CommandTestCase(unittest.TestCase): cmd = self.cmd cmd.option1 = 'ok,dok' cmd.ensure_string_list('option1') - self.assertEquals(cmd.option1, ['ok', 'dok']) + self.assertEqual(cmd.option1, ['ok', 'dok']) cmd.option2 = ['xxx', 'www'] cmd.ensure_string_list('option2') @@ -109,14 +109,14 @@ class CommandTestCase(unittest.TestCase): with captured_stdout() as stdout: cmd.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') debug.DEBUG = True try: with captured_stdout() as stdout: cmd.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), 'xxx\n') + self.assertEqual(stdout.read(), 'xxx\n') finally: debug.DEBUG = False diff --git a/Lib/distutils/tests/test_config.py b/Lib/distutils/tests/test_config.py index 6c85efad..8d71234 100644 --- a/Lib/distutils/tests/test_config.py +++ b/Lib/distutils/tests/test_config.py @@ -90,7 +90,7 @@ class PyPIRCCommandTestCase(support.TempdirManager, waited = [('password', 'secret'), ('realm', 'pypi'), ('repository', 'http://pypi.python.org/pypi'), ('server', 'server1'), ('username', 'me')] - self.assertEquals(config, waited) + self.assertEqual(config, waited) # old format self.write_file(self.rc, PYPIRC_OLD) @@ -100,7 +100,7 @@ class PyPIRCCommandTestCase(support.TempdirManager, waited = [('password', 'secret'), ('realm', 'pypi'), ('repository', 'http://pypi.python.org/pypi'), ('server', 'server-login'), ('username', 'tarek')] - self.assertEquals(config, waited) + self.assertEqual(config, waited) def test_server_empty_registration(self): cmd = self._cmd(self.dist) @@ -111,7 +111,7 @@ class PyPIRCCommandTestCase(support.TempdirManager, f = open(rc) try: content = f.read() - self.assertEquals(content, WANTED) + self.assertEqual(content, WANTED) finally: f.close() diff --git a/Lib/distutils/tests/test_config_cmd.py b/Lib/distutils/tests/test_config_cmd.py index ef2e7bc..fcb798e 100644 --- a/Lib/distutils/tests/test_config_cmd.py +++ b/Lib/distutils/tests/test_config_cmd.py @@ -34,7 +34,7 @@ class ConfigTestCase(support.LoggingSilencer, f.close() dump_file(this_file, 'I am the header') - self.assertEquals(len(self._logs), numlines+1) + self.assertEqual(len(self._logs), numlines+1) def test_search_cpp(self): if sys.platform == 'win32': @@ -44,10 +44,10 @@ class ConfigTestCase(support.LoggingSilencer, # simple pattern searches match = cmd.search_cpp(pattern='xxx', body='// xxx') - self.assertEquals(match, 0) + self.assertEqual(match, 0) match = cmd.search_cpp(pattern='_configtest', body='// xxx') - self.assertEquals(match, 1) + self.assertEqual(match, 1) def test_finalize_options(self): # finalize_options does a bit of transformation @@ -59,9 +59,9 @@ class ConfigTestCase(support.LoggingSilencer, cmd.library_dirs = 'three%sfour' % os.pathsep cmd.ensure_finalized() - self.assertEquals(cmd.include_dirs, ['one', 'two']) - self.assertEquals(cmd.libraries, ['one']) - self.assertEquals(cmd.library_dirs, ['three', 'four']) + self.assertEqual(cmd.include_dirs, ['one', 'two']) + self.assertEqual(cmd.libraries, ['one']) + self.assertEqual(cmd.library_dirs, ['three', 'four']) def test_clean(self): # _clean removes files diff --git a/Lib/distutils/tests/test_core.py b/Lib/distutils/tests/test_core.py index 63f6b31..74d1f3b 100644 --- a/Lib/distutils/tests/test_core.py +++ b/Lib/distutils/tests/test_core.py @@ -89,7 +89,7 @@ class CoreTestCase(support.EnvironGuard, unittest.TestCase): with captured_stdout() as stdout: distutils.core.setup(name='bar') stdout.seek(0) - self.assertEquals(stdout.read(), 'bar\n') + self.assertEqual(stdout.read(), 'bar\n') distutils.core.DEBUG = True try: @@ -99,7 +99,7 @@ class CoreTestCase(support.EnvironGuard, unittest.TestCase): distutils.core.DEBUG = False stdout.seek(0) wanted = "options (after parsing config files):\n" - self.assertEquals(stdout.readlines()[0], wanted) + self.assertEqual(stdout.readlines()[0], wanted) def test_suite(): return unittest.makeSuite(CoreTestCase) diff --git a/Lib/distutils/tests/test_dep_util.py b/Lib/distutils/tests/test_dep_util.py index d81d914..3550819 100644 --- a/Lib/distutils/tests/test_dep_util.py +++ b/Lib/distutils/tests/test_dep_util.py @@ -42,8 +42,8 @@ class DepUtilTestCase(support.TempdirManager, unittest.TestCase): self.write_file(two) self.write_file(four) - self.assertEquals(newer_pairwise([one, two], [three, four]), - ([one],[three])) + self.assertEqual(newer_pairwise([one, two], [three, four]), + ([one],[three])) def test_newer_group(self): tmpdir = self.mkdtemp() diff --git a/Lib/distutils/tests/test_dir_util.py b/Lib/distutils/tests/test_dir_util.py index aa9f9eb..84a0ec6 100644 --- a/Lib/distutils/tests/test_dir_util.py +++ b/Lib/distutils/tests/test_dir_util.py @@ -37,18 +37,18 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): mkpath(self.target, verbose=0) wanted = [] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) remove_tree(self.root_target, verbose=0) mkpath(self.target, verbose=1) wanted = ['creating %s' % self.root_target, 'creating %s' % self.target] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) self._logs = [] remove_tree(self.root_target, verbose=1) wanted = ["removing '%s' (and everything under it)" % self.root_target] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) @unittest.skipIf(sys.platform.startswith('win'), "This test is only appropriate for POSIX-like systems.") @@ -66,12 +66,12 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): def test_create_tree_verbosity(self): create_tree(self.root_target, ['one', 'two', 'three'], verbose=0) - self.assertEquals(self._logs, []) + self.assertEqual(self._logs, []) remove_tree(self.root_target, verbose=0) wanted = ['creating %s' % self.root_target] create_tree(self.root_target, ['one', 'two', 'three'], verbose=1) - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) remove_tree(self.root_target, verbose=0) @@ -81,7 +81,7 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): mkpath(self.target, verbose=0) copy_tree(self.target, self.target2, verbose=0) - self.assertEquals(self._logs, []) + self.assertEqual(self._logs, []) remove_tree(self.root_target, verbose=0) @@ -95,18 +95,18 @@ class DirUtilTestCase(support.TempdirManager, unittest.TestCase): wanted = ['copying %s -> %s' % (a_file, self.target2)] copy_tree(self.target, self.target2, verbose=1) - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) remove_tree(self.root_target, verbose=0) remove_tree(self.target2, verbose=0) def test_ensure_relative(self): if os.sep == '/': - self.assertEquals(ensure_relative('/home/foo'), 'home/foo') - self.assertEquals(ensure_relative('some/path'), 'some/path') + self.assertEqual(ensure_relative('/home/foo'), 'home/foo') + self.assertEqual(ensure_relative('some/path'), 'some/path') else: # \\ - self.assertEquals(ensure_relative('c:\\home\\foo'), 'c:home\\foo') - self.assertEquals(ensure_relative('home\\foo'), 'home\\foo') + self.assertEqual(ensure_relative('c:\\home\\foo'), 'c:home\\foo') + self.assertEqual(ensure_relative('home\\foo'), 'home\\foo') def test_suite(): return unittest.makeSuite(DirUtilTestCase) diff --git a/Lib/distutils/tests/test_dist.py b/Lib/distutils/tests/test_dist.py index d9b413f..8ab7e9f 100644 --- a/Lib/distutils/tests/test_dist.py +++ b/Lib/distutils/tests/test_dist.py @@ -70,13 +70,13 @@ class DistributionTestCase(support.TempdirManager, with captured_stdout() as stdout: self.create_distribution(files) stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') distutils.dist.DEBUG = True try: with captured_stdout() as stdout: self.create_distribution(files) stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') finally: distutils.dist.DEBUG = False @@ -175,7 +175,7 @@ class DistributionTestCase(support.TempdirManager, finally: warnings.warn = old_warn - self.assertEquals(len(warns), 0) + self.assertEqual(len(warns), 0) def test_finalize_options(self): @@ -186,20 +186,20 @@ class DistributionTestCase(support.TempdirManager, dist.finalize_options() # finalize_option splits platforms and keywords - self.assertEquals(dist.metadata.platforms, ['one', 'two']) - self.assertEquals(dist.metadata.keywords, ['one', 'two']) + self.assertEqual(dist.metadata.platforms, ['one', 'two']) + self.assertEqual(dist.metadata.keywords, ['one', 'two']) def test_get_command_packages(self): dist = Distribution() - self.assertEquals(dist.command_packages, None) + self.assertEqual(dist.command_packages, None) cmds = dist.get_command_packages() - self.assertEquals(cmds, ['distutils.command']) - self.assertEquals(dist.command_packages, - ['distutils.command']) + self.assertEqual(cmds, ['distutils.command']) + self.assertEqual(dist.command_packages, + ['distutils.command']) dist.command_packages = 'one,two' cmds = dist.get_command_packages() - self.assertEquals(cmds, ['distutils.command', 'one', 'two']) + self.assertEqual(cmds, ['distutils.command', 'one', 'two']) def test_announce(self): @@ -236,7 +236,7 @@ class DistributionTestCase(support.TempdirManager, os.path.expanduser = old_expander # make sure --no-user-cfg disables the user cfg file - self.assertEquals(len(all_files)-1, len(files)) + self.assertEqual(len(all_files)-1, len(files)) class MetadataTestCase(support.TempdirManager, support.EnvironGuard, @@ -368,8 +368,8 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, def test_fix_help_options(self): help_tuples = [('a', 'b', 'c', 'd'), (1, 2, 3, 4)] fancy_options = fix_help_options(help_tuples) - self.assertEquals(fancy_options[0], ('a', 'b', 'c')) - self.assertEquals(fancy_options[1], (1, 2, 3)) + self.assertEqual(fancy_options[0], ('a', 'b', 'c')) + self.assertEqual(fancy_options[1], (1, 2, 3)) def test_show_help(self): # smoke test, just makes sure some help is displayed @@ -417,14 +417,14 @@ class MetadataTestCase(support.TempdirManager, support.EnvironGuard, PKG_INFO.seek(0) metadata.read_pkg_file(PKG_INFO) - self.assertEquals(metadata.name, "package") - self.assertEquals(metadata.version, "1.0") - self.assertEquals(metadata.description, "xxx") - self.assertEquals(metadata.download_url, 'http://example.com') - self.assertEquals(metadata.keywords, ['one', 'two']) - self.assertEquals(metadata.platforms, ['UNKNOWN']) - self.assertEquals(metadata.obsoletes, None) - self.assertEquals(metadata.requires, ['foo']) + self.assertEqual(metadata.name, "package") + self.assertEqual(metadata.version, "1.0") + self.assertEqual(metadata.description, "xxx") + self.assertEqual(metadata.download_url, 'http://example.com') + self.assertEqual(metadata.keywords, ['one', 'two']) + self.assertEqual(metadata.platforms, ['UNKNOWN']) + self.assertEqual(metadata.obsoletes, None) + self.assertEqual(metadata.requires, ['foo']) def test_suite(): suite = unittest.TestSuite() diff --git a/Lib/distutils/tests/test_file_util.py b/Lib/distutils/tests/test_file_util.py index 823f211..dbc6283 100644 --- a/Lib/distutils/tests/test_file_util.py +++ b/Lib/distutils/tests/test_file_util.py @@ -38,14 +38,14 @@ class FileUtilTestCase(support.TempdirManager, unittest.TestCase): move_file(self.source, self.target, verbose=0) wanted = [] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) # back to original state move_file(self.target, self.source, verbose=0) move_file(self.source, self.target, verbose=1) wanted = ['moving %s -> %s' % (self.source, self.target)] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) # back to original state move_file(self.target, self.source, verbose=0) @@ -55,7 +55,7 @@ class FileUtilTestCase(support.TempdirManager, unittest.TestCase): os.mkdir(self.target_dir) move_file(self.source, self.target_dir, verbose=1) wanted = ['moving %s -> %s' % (self.source, self.target_dir)] - self.assertEquals(self._logs, wanted) + self.assertEqual(self._logs, wanted) def test_write_file(self): lines = ['a', 'b', 'c'] @@ -63,7 +63,7 @@ class FileUtilTestCase(support.TempdirManager, unittest.TestCase): foo = os.path.join(dir, 'foo') write_file(foo, lines) content = [line.strip() for line in open(foo).readlines()] - self.assertEquals(content, lines) + self.assertEqual(content, lines) def test_copy_file(self): src_dir = self.mkdtemp() diff --git a/Lib/distutils/tests/test_filelist.py b/Lib/distutils/tests/test_filelist.py index 0cbb48b..32c56c7 100644 --- a/Lib/distutils/tests/test_filelist.py +++ b/Lib/distutils/tests/test_filelist.py @@ -24,15 +24,15 @@ class FileListTestCase(unittest.TestCase): def test_glob_to_re(self): # simple cases - self.assertEquals(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)') - self.assertEquals(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)') - self.assertEquals(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)') + self.assertEqual(glob_to_re('foo*'), 'foo[^/]*\\Z(?ms)') + self.assertEqual(glob_to_re('foo?'), 'foo[^/]\\Z(?ms)') + self.assertEqual(glob_to_re('foo??'), 'foo[^/][^/]\\Z(?ms)') # special cases - self.assertEquals(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)') - self.assertEquals(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)') - self.assertEquals(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)') - self.assertEquals(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)') + self.assertEqual(glob_to_re(r'foo\\*'), r'foo\\\\[^/]*\Z(?ms)') + self.assertEqual(glob_to_re(r'foo\\\*'), r'foo\\\\\\[^/]*\Z(?ms)') + self.assertEqual(glob_to_re('foo????'), r'foo[^/][^/][^/][^/]\Z(?ms)') + self.assertEqual(glob_to_re(r'foo\\??'), r'foo\\\\[^/][^/]\Z(?ms)') def test_process_template_line(self): # testing all MANIFEST.in template patterns @@ -60,21 +60,21 @@ class FileListTestCase(unittest.TestCase): join('global', 'two.txt'), join('f', 'o', 'f.oo'), join('dir', 'graft-one'), join('dir', 'dir2', 'graft2')] - self.assertEquals(file_list.files, wanted) + self.assertEqual(file_list.files, wanted) def test_debug_print(self): file_list = FileList() with captured_stdout() as stdout: file_list.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), '') + self.assertEqual(stdout.read(), '') debug.DEBUG = True try: with captured_stdout() as stdout: file_list.debug_print('xxx') stdout.seek(0) - self.assertEquals(stdout.read(), 'xxx\n') + self.assertEqual(stdout.read(), 'xxx\n') finally: debug.DEBUG = False diff --git a/Lib/distutils/tests/test_install_data.py b/Lib/distutils/tests/test_install_data.py index 377ae86..86db4a1 100644 --- a/Lib/distutils/tests/test_install_data.py +++ b/Lib/distutils/tests/test_install_data.py @@ -27,14 +27,14 @@ class InstallDataTestCase(support.TempdirManager, self.write_file(two, 'xxx') cmd.data_files = [one, (inst2, [two])] - self.assertEquals(cmd.get_inputs(), [one, (inst2, [two])]) + self.assertEqual(cmd.get_inputs(), [one, (inst2, [two])]) # let's run the command cmd.ensure_finalized() cmd.run() # let's check the result - self.assertEquals(len(cmd.get_outputs()), 2) + self.assertEqual(len(cmd.get_outputs()), 2) rtwo = os.path.split(two)[-1] self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) rone = os.path.split(one)[-1] @@ -47,7 +47,7 @@ class InstallDataTestCase(support.TempdirManager, cmd.run() # let's check the result - self.assertEquals(len(cmd.get_outputs()), 2) + self.assertEqual(len(cmd.get_outputs()), 2) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst, rone))) cmd.outfiles = [] @@ -65,7 +65,7 @@ class InstallDataTestCase(support.TempdirManager, cmd.run() # let's check the result - self.assertEquals(len(cmd.get_outputs()), 4) + self.assertEqual(len(cmd.get_outputs()), 4) self.assertTrue(os.path.exists(os.path.join(inst2, rtwo))) self.assertTrue(os.path.exists(os.path.join(inst, rone))) diff --git a/Lib/distutils/tests/test_install_headers.py b/Lib/distutils/tests/test_install_headers.py index 5b32b13..aa8a4e6 100644 --- a/Lib/distutils/tests/test_install_headers.py +++ b/Lib/distutils/tests/test_install_headers.py @@ -23,7 +23,7 @@ class InstallHeadersTestCase(support.TempdirManager, pkg_dir, dist = self.create_dist(headers=headers) cmd = install_headers(dist) - self.assertEquals(cmd.get_inputs(), headers) + self.assertEqual(cmd.get_inputs(), headers) # let's run the command cmd.install_dir = os.path.join(pkg_dir, 'inst') @@ -31,7 +31,7 @@ class InstallHeadersTestCase(support.TempdirManager, cmd.run() # let's check the results - self.assertEquals(len(cmd.get_outputs()), 2) + self.assertEqual(len(cmd.get_outputs()), 2) def test_suite(): return unittest.makeSuite(InstallHeadersTestCase) diff --git a/Lib/distutils/tests/test_install_lib.py b/Lib/distutils/tests/test_install_lib.py index 13d27ab..754ea63 100644 --- a/Lib/distutils/tests/test_install_lib.py +++ b/Lib/distutils/tests/test_install_lib.py @@ -18,8 +18,8 @@ class InstallLibTestCase(support.TempdirManager, cmd = install_lib(dist) cmd.finalize_options() - self.assertEquals(cmd.compile, 1) - self.assertEquals(cmd.optimize, 0) + self.assertEqual(cmd.compile, 1) + self.assertEqual(cmd.optimize, 0) # optimize must be 0, 1, or 2 cmd.optimize = 'foo' @@ -29,7 +29,7 @@ class InstallLibTestCase(support.TempdirManager, cmd.optimize = '2' cmd.finalize_options() - self.assertEquals(cmd.optimize, 2) + self.assertEqual(cmd.optimize, 2) def _setup_byte_compile(self): pkg_dir, dist = self.create_dist() @@ -81,7 +81,7 @@ class InstallLibTestCase(support.TempdirManager, cmd.distribution.script_name = 'setup.py' # get_input should return 2 elements - self.assertEquals(len(cmd.get_inputs()), 2) + self.assertEqual(len(cmd.get_inputs()), 2) def test_dont_write_bytecode(self): # makes sure byte_compile is not used diff --git a/Lib/distutils/tests/test_msvc9compiler.py b/Lib/distutils/tests/test_msvc9compiler.py index 567505d..b8e2209 100644 --- a/Lib/distutils/tests/test_msvc9compiler.py +++ b/Lib/distutils/tests/test_msvc9compiler.py @@ -103,7 +103,7 @@ class msvc9compilerTestCase(support.TempdirManager, import _winreg HKCU = _winreg.HKEY_CURRENT_USER keys = Reg.read_keys(HKCU, 'xxxx') - self.assertEquals(keys, None) + self.assertEqual(keys, None) keys = Reg.read_keys(HKCU, r'Control Panel') self.assertTrue('Desktop' in keys) @@ -130,7 +130,7 @@ class msvc9compilerTestCase(support.TempdirManager, f.close() # makes sure the manifest was properly cleaned - self.assertEquals(content, _CLEANED_MANIFEST) + self.assertEqual(content, _CLEANED_MANIFEST) def test_suite(): diff --git a/Lib/distutils/tests/test_register.py b/Lib/distutils/tests/test_register.py index 6da479b..915427b 100644 --- a/Lib/distutils/tests/test_register.py +++ b/Lib/distutils/tests/test_register.py @@ -122,7 +122,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): f = open(self.rc) try: content = f.read() - self.assertEquals(content, WANTED_PYPIRC) + self.assertEqual(content, WANTED_PYPIRC) finally: f.close() @@ -141,7 +141,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): self.assertTrue(self.conn.reqs, 2) req1 = dict(self.conn.reqs[0].headers) req2 = dict(self.conn.reqs[1].headers) - self.assertEquals(req2['Content-length'], req1['Content-length']) + self.assertEqual(req2['Content-length'], req1['Content-length']) self.assertTrue('xxx' in self.conn.reqs[1].data) def test_password_not_in_file(self): @@ -154,7 +154,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): # dist.password should be set # therefore used afterwards by other commands - self.assertEquals(cmd.distribution.password, 'password') + self.assertEqual(cmd.distribution.password, 'password') def test_registering(self): # this test runs choice 2 @@ -171,7 +171,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): self.assertTrue(self.conn.reqs, 1) req = self.conn.reqs[0] headers = dict(req.headers) - self.assertEquals(headers['Content-length'], '608') + self.assertEqual(headers['Content-length'], '608') self.assertTrue('tarek' in req.data) def test_password_reset(self): @@ -189,7 +189,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): self.assertTrue(self.conn.reqs, 1) req = self.conn.reqs[0] headers = dict(req.headers) - self.assertEquals(headers['Content-length'], '290') + self.assertEqual(headers['Content-length'], '290') self.assertTrue('tarek' in req.data) def test_strict(self): @@ -252,7 +252,7 @@ class RegisterTestCase(PyPIRCCommandTestCase): with check_warnings() as w: warnings.simplefilter("always") cmd.check_metadata() - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) def test_suite(): return unittest.makeSuite(RegisterTestCase) diff --git a/Lib/distutils/tests/test_sdist.py b/Lib/distutils/tests/test_sdist.py index 7cebbf5..b9d86bb 100644 --- a/Lib/distutils/tests/test_sdist.py +++ b/Lib/distutils/tests/test_sdist.py @@ -127,7 +127,7 @@ class SDistTestCase(PyPIRCCommandTestCase): # now let's check what we have dist_folder = join(self.tmp_dir, 'dist') files = os.listdir(dist_folder) - self.assertEquals(files, ['fake-1.0.zip']) + self.assertEqual(files, ['fake-1.0.zip']) zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip')) try: @@ -136,7 +136,7 @@ class SDistTestCase(PyPIRCCommandTestCase): zip_file.close() # making sure everything has been pruned correctly - self.assertEquals(len(content), 4) + self.assertEqual(len(content), 4) @unittest.skipUnless(zlib, "requires zlib") def test_make_distribution(self): @@ -158,8 +158,7 @@ class SDistTestCase(PyPIRCCommandTestCase): dist_folder = join(self.tmp_dir, 'dist') result = os.listdir(dist_folder) result.sort() - self.assertEquals(result, - ['fake-1.0.tar', 'fake-1.0.tar.gz'] ) + self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz'] ) os.remove(join(dist_folder, 'fake-1.0.tar')) os.remove(join(dist_folder, 'fake-1.0.tar.gz')) @@ -172,8 +171,7 @@ class SDistTestCase(PyPIRCCommandTestCase): result = os.listdir(dist_folder) result.sort() - self.assertEquals(result, - ['fake-1.0.tar', 'fake-1.0.tar.gz']) + self.assertEqual(result, ['fake-1.0.tar', 'fake-1.0.tar.gz']) @unittest.skipUnless(zlib, "requires zlib") def test_add_defaults(self): @@ -222,7 +220,7 @@ class SDistTestCase(PyPIRCCommandTestCase): # now let's check what we have dist_folder = join(self.tmp_dir, 'dist') files = os.listdir(dist_folder) - self.assertEquals(files, ['fake-1.0.zip']) + self.assertEqual(files, ['fake-1.0.zip']) zip_file = zipfile.ZipFile(join(dist_folder, 'fake-1.0.zip')) try: @@ -231,13 +229,13 @@ class SDistTestCase(PyPIRCCommandTestCase): zip_file.close() # making sure everything was added - self.assertEquals(len(content), 11) + self.assertEqual(len(content), 11) # checking the MANIFEST f = open(join(self.tmp_dir, 'MANIFEST')) try: manifest = f.read() - self.assertEquals(manifest, MANIFEST % {'sep': os.sep}) + self.assertEqual(manifest, MANIFEST % {'sep': os.sep}) finally: f.close() @@ -251,7 +249,7 @@ class SDistTestCase(PyPIRCCommandTestCase): cmd.ensure_finalized() cmd.run() warnings = self.get_logs(WARN) - self.assertEquals(len(warnings), 2) + self.assertEqual(len(warnings), 2) # trying with a complete set of metadata self.clear_logs() @@ -260,7 +258,7 @@ class SDistTestCase(PyPIRCCommandTestCase): cmd.metadata_check = 0 cmd.run() warnings = self.get_logs(WARN) - self.assertEquals(len(warnings), 0) + self.assertEqual(len(warnings), 0) def test_check_metadata_deprecated(self): # makes sure make_metadata is deprecated @@ -268,7 +266,7 @@ class SDistTestCase(PyPIRCCommandTestCase): with check_warnings() as w: warnings.simplefilter("always") cmd.check_metadata() - self.assertEquals(len(w.warnings), 1) + self.assertEqual(len(w.warnings), 1) def test_show_formats(self): with captured_stdout() as stdout: @@ -278,7 +276,7 @@ class SDistTestCase(PyPIRCCommandTestCase): num_formats = len(ARCHIVE_FORMATS.keys()) output = [line for line in stdout.getvalue().split('\n') if line.strip().startswith('--formats=')] - self.assertEquals(len(output), num_formats) + self.assertEqual(len(output), num_formats) def test_finalize_options(self): @@ -286,9 +284,9 @@ class SDistTestCase(PyPIRCCommandTestCase): cmd.finalize_options() # default options set by finalize - self.assertEquals(cmd.manifest, 'MANIFEST') - self.assertEquals(cmd.template, 'MANIFEST.in') - self.assertEquals(cmd.dist_dir, 'dist') + self.assertEqual(cmd.manifest, 'MANIFEST') + self.assertEqual(cmd.template, 'MANIFEST.in') + self.assertEqual(cmd.dist_dir, 'dist') # formats has to be a string splitable on (' ', ',') or # a stringlist @@ -325,8 +323,8 @@ class SDistTestCase(PyPIRCCommandTestCase): archive = tarfile.open(archive_name) try: for member in archive.getmembers(): - self.assertEquals(member.uid, 0) - self.assertEquals(member.gid, 0) + self.assertEqual(member.uid, 0) + self.assertEqual(member.gid, 0) finally: archive.close() @@ -347,7 +345,7 @@ class SDistTestCase(PyPIRCCommandTestCase): # rights (see #7408) try: for member in archive.getmembers(): - self.assertEquals(member.uid, os.getuid()) + self.assertEqual(member.uid, os.getuid()) finally: archive.close() @@ -369,7 +367,7 @@ class SDistTestCase(PyPIRCCommandTestCase): finally: f.close() - self.assertEquals(len(manifest), 5) + self.assertEqual(len(manifest), 5) # adding a file self.write_file((self.tmp_dir, 'somecode', 'doc2.txt'), '#') @@ -389,7 +387,7 @@ class SDistTestCase(PyPIRCCommandTestCase): f.close() # do we have the new file in MANIFEST ? - self.assertEquals(len(manifest2), 6) + self.assertEqual(len(manifest2), 6) self.assertIn('doc2.txt', manifest2[-1]) def test_manifest_marker(self): diff --git a/Lib/distutils/tests/test_spawn.py b/Lib/distutils/tests/test_spawn.py index b9fd610..6caf039 100644 --- a/Lib/distutils/tests/test_spawn.py +++ b/Lib/distutils/tests/test_spawn.py @@ -20,7 +20,7 @@ class SpawnTestCase(support.TempdirManager, (['nochange', 'nospace'], ['nochange', 'nospace'])): res = _nt_quote_args(args) - self.assertEquals(res, wanted) + self.assertEqual(res, wanted) @unittest.skipUnless(os.name in ('nt', 'posix'), diff --git a/Lib/distutils/tests/test_sysconfig.py b/Lib/distutils/tests/test_sysconfig.py index 8449ddc..49570c4 100644 --- a/Lib/distutils/tests/test_sysconfig.py +++ b/Lib/distutils/tests/test_sysconfig.py @@ -36,7 +36,7 @@ class SysconfigTestCase(support.EnvironGuard, sysconfig.get_python_lib(prefix=TESTFN)) _sysconfig = __import__('sysconfig') res = sysconfig.get_python_lib(True, True) - self.assertEquals(_sysconfig.get_path('platstdlib'), res) + self.assertEqual(_sysconfig.get_path('platstdlib'), res) def test_get_python_inc(self): inc_dir = sysconfig.get_python_inc() @@ -56,8 +56,8 @@ class SysconfigTestCase(support.EnvironGuard, finally: fd.close() d = sysconfig.parse_makefile(self.makefile) - self.assertEquals(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", - 'OTHER': 'foo'}) + self.assertEqual(d, {'CONFIG_ARGS': "'--arg1=optarg1' 'ENV=LIB'", + 'OTHER': 'foo'}) def test_parse_makefile_literal_dollar(self): self.makefile = test.test_support.TESTFN @@ -68,8 +68,8 @@ class SysconfigTestCase(support.EnvironGuard, finally: fd.close() d = sysconfig.parse_makefile(self.makefile) - self.assertEquals(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", - 'OTHER': 'foo'}) + self.assertEqual(d, {'CONFIG_ARGS': r"'--arg1=optarg1' 'ENV=\$LIB'", + 'OTHER': 'foo'}) def test_suite(): diff --git a/Lib/distutils/tests/test_text_file.py b/Lib/distutils/tests/test_text_file.py index 3093097..f1e32b6 100644 --- a/Lib/distutils/tests/test_text_file.py +++ b/Lib/distutils/tests/test_text_file.py @@ -48,7 +48,7 @@ class TextFileTestCase(support.TempdirManager, unittest.TestCase): def test_input(count, description, file, expected_result): result = file.readlines() - self.assertEquals(result, expected_result) + self.assertEqual(result, expected_result) tmpdir = self.mkdtemp() filename = os.path.join(tmpdir, "test.txt") diff --git a/Lib/distutils/tests/test_upload.py b/Lib/distutils/tests/test_upload.py index 3ae8949..f45ee41 100644 --- a/Lib/distutils/tests/test_upload.py +++ b/Lib/distutils/tests/test_upload.py @@ -80,7 +80,7 @@ class uploadTestCase(PyPIRCCommandTestCase): for attr, waited in (('username', 'me'), ('password', 'secret'), ('realm', 'pypi'), ('repository', 'http://pypi.python.org/pypi')): - self.assertEquals(getattr(cmd, attr), waited) + self.assertEqual(getattr(cmd, attr), waited) def test_saved_password(self): # file with no password @@ -90,14 +90,14 @@ class uploadTestCase(PyPIRCCommandTestCase): dist = Distribution() cmd = upload(dist) cmd.finalize_options() - self.assertEquals(cmd.password, None) + self.assertEqual(cmd.password, None) # make sure we get it as well, if another command # initialized it at the dist level dist.password = 'xxx' cmd = upload(dist) cmd.finalize_options() - self.assertEquals(cmd.password, 'xxx') + self.assertEqual(cmd.password, 'xxx') def test_upload(self): tmp = self.mkdtemp() @@ -116,11 +116,11 @@ class uploadTestCase(PyPIRCCommandTestCase): # what did we send ? self.assertIn('dédé', self.last_open.req.data) headers = dict(self.last_open.req.headers) - self.assertEquals(headers['Content-length'], '2085') + self.assertEqual(headers['Content-length'], '2085') self.assertTrue(headers['Content-type'].startswith('multipart/form-data')) - self.assertEquals(self.last_open.req.get_method(), 'POST') - self.assertEquals(self.last_open.req.get_full_url(), - 'http://pypi.python.org/pypi') + self.assertEqual(self.last_open.req.get_method(), 'POST') + self.assertEqual(self.last_open.req.get_full_url(), + 'http://pypi.python.org/pypi') self.assertTrue('xxx' in self.last_open.req.data) auth = self.last_open.req.headers['Authorization'] self.assertFalse('\n' in auth) diff --git a/Lib/distutils/tests/test_version.py b/Lib/distutils/tests/test_version.py index 747db94..1d9fbc7 100644 --- a/Lib/distutils/tests/test_version.py +++ b/Lib/distutils/tests/test_version.py @@ -7,12 +7,12 @@ class VersionTestCase(unittest.TestCase): def test_prerelease(self): version = StrictVersion('1.2.3a1') - self.assertEquals(version.version, (1, 2, 3)) - self.assertEquals(version.prerelease, ('a', 1)) - self.assertEquals(str(version), '1.2.3a1') + self.assertEqual(version.version, (1, 2, 3)) + self.assertEqual(version.prerelease, ('a', 1)) + self.assertEqual(str(version), '1.2.3a1') version = StrictVersion('1.2.0') - self.assertEquals(str(version), '1.2') + self.assertEqual(str(version), '1.2') def test_cmp_strict(self): versions = (('1.5.1', '1.5.2b2', -1), @@ -41,9 +41,9 @@ class VersionTestCase(unittest.TestCase): raise AssertionError(("cmp(%s, %s) " "shouldn't raise ValueError") % (v1, v2)) - self.assertEquals(res, wanted, - 'cmp(%s, %s) should be %s, got %s' % - (v1, v2, wanted, res)) + self.assertEqual(res, wanted, + 'cmp(%s, %s) should be %s, got %s' % + (v1, v2, wanted, res)) def test_cmp(self): @@ -59,9 +59,9 @@ class VersionTestCase(unittest.TestCase): for v1, v2, wanted in versions: res = LooseVersion(v1).__cmp__(LooseVersion(v2)) - self.assertEquals(res, wanted, - 'cmp(%s, %s) should be %s, got %s' % - (v1, v2, wanted, res)) + self.assertEqual(res, wanted, + 'cmp(%s, %s) should be %s, got %s' % + (v1, v2, wanted, res)) def test_suite(): return unittest.makeSuite(VersionTestCase) diff --git a/Lib/email/test/test_email.py b/Lib/email/test/test_email.py index 58edd0c..d93287a 100644 --- a/Lib/email/test/test_email.py +++ b/Lib/email/test/test_email.py @@ -40,13 +40,13 @@ EMPTYSTRING = '' SPACE = ' ' - + def openfile(filename, mode='r'): path = os.path.join(os.path.dirname(landmark), 'data', filename) return open(path, mode) - + # Base test class class TestEmailBase(unittest.TestCase): def ndiffAssertEqual(self, first, second): @@ -68,7 +68,7 @@ class TestEmailBase(unittest.TestCase): return msg - + # Test various aspects of the Message class's API class TestMessageAPI(TestEmailBase): def test_get_all(self): @@ -543,7 +543,7 @@ class TestMessageAPI(TestEmailBase): self.assertEqual('us-ascii', msg.get_content_charset()) - + # Test the email.Encoders module class TestEncoders(unittest.TestCase): def test_encode_empty_payload(self): @@ -572,7 +572,7 @@ class TestEncoders(unittest.TestCase): msg = email.MIMEText.MIMEText('\xca\xb8', _charset='euc-jp') eq(msg['content-transfer-encoding'], '7bit') - + # Test long header wrapping class TestLongHeaders(TestEmailBase): def test_split_long_continuation(self): @@ -893,7 +893,7 @@ List: List-Unsubscribe: model->generator idempotency. IOW, read a message # in, parse it into a message object tree, then without touching the tree, # regenerate the plain text. The original text and the transformed text @@ -1964,7 +1964,7 @@ class TestIdempotent(TestEmailBase): eq(text, s.getvalue()) def test_parse_text_message(self): - eq = self.assertEquals + eq = self.assertEqual msg, text = self._msgobj('msg_01.txt') eq(msg.get_content_type(), 'text/plain') eq(msg.get_content_maintype(), 'text') @@ -1976,7 +1976,7 @@ class TestIdempotent(TestEmailBase): self._idempotent(msg, text) def test_parse_untyped_message(self): - eq = self.assertEquals + eq = self.assertEqual msg, text = self._msgobj('msg_03.txt') eq(msg.get_content_type(), 'text/plain') eq(msg.get_params(), None) @@ -2048,7 +2048,7 @@ class TestIdempotent(TestEmailBase): self._idempotent(msg, text) def test_content_type(self): - eq = self.assertEquals + eq = self.assertEqual unless = self.assertTrue # Get a message object and reset the seek pointer for other tests msg, text = self._msgobj('msg_05.txt') @@ -2080,7 +2080,7 @@ class TestIdempotent(TestEmailBase): eq(msg4.get_payload(), 'Yadda yadda yadda\n') def test_parser(self): - eq = self.assertEquals + eq = self.assertEqual unless = self.assertTrue msg, text = self._msgobj('msg_06.txt') # Check some of the outer headers @@ -2097,7 +2097,7 @@ class TestIdempotent(TestEmailBase): eq(msg1.get_payload(), '\n') - + # Test various other bits of the package's functionality class TestMiscellaneous(TestEmailBase): def test_message_from_string(self): @@ -2452,7 +2452,7 @@ multipart/report """) - + # Test the iterator/generators class TestIterators(TestEmailBase): def test_body_line_iterator(self): @@ -2545,7 +2545,7 @@ Do you like this message? self.assertTrue(''.join([il for il, n in imt]) == ''.join(om)) - + class TestParsers(TestEmailBase): def test_header_parser(self): eq = self.assertEqual @@ -2708,7 +2708,7 @@ Here's the message body msg = email.message_from_string(m) self.assertTrue(msg.get_payload(0).get_payload().endswith('\r\n')) - + class TestBase64(unittest.TestCase): def test_len(self): eq = self.assertEqual @@ -2780,7 +2780,7 @@ eHh4eCB4eHh4IA==\r =?iso-8859-1?b?eHh4eCB4eHh4IHh4eHgg?=""") - + class TestQuopri(unittest.TestCase): def setUp(self): self.hlit = [chr(x) for x in range(ord('a'), ord('z')+1)] + \ @@ -2890,7 +2890,7 @@ one line two line""") - + # Test the Charset class class TestCharset(unittest.TestCase): def tearDown(self): @@ -2951,7 +2951,7 @@ class TestCharset(unittest.TestCase): charset = Charset('utf8') self.assertEqual(str(charset), 'utf-8') - + # Test multilingual MIME headers. class TestHeader(TestEmailBase): def test_simple(self): @@ -3114,7 +3114,7 @@ A very long line that must get split to something other than at the raises(Errors.HeaderParseError, decode_header, s) - + # Test RFC 2231 header parameters (en/de)coding class TestRFC2231(TestEmailBase): def test_get_param(self): @@ -3426,7 +3426,7 @@ Content-Type: application/x-foo; eq(s, 'My Document For You') - + # Tests to ensure that signed parts of an email are completely preserved, as # required by RFC1847 section 2.1. Note that these are incomplete, because the # email package does not currently always preserve the body. See issue 1670765. @@ -3462,7 +3462,7 @@ class TestSigned(TestEmailBase): self._signed_parts_eq(original, result) - + def _testclasses(): mod = sys.modules[__name__] return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')] @@ -3480,6 +3480,6 @@ def test_main(): run_unittest(testclass) - + if __name__ == '__main__': unittest.main(defaultTest='suite') diff --git a/Lib/email/test/test_email_renamed.py b/Lib/email/test/test_email_renamed.py index 481c40f..497b66b 100644 --- a/Lib/email/test/test_email_renamed.py +++ b/Lib/email/test/test_email_renamed.py @@ -41,13 +41,13 @@ EMPTYSTRING = '' SPACE = ' ' - + def openfile(filename, mode='r'): path = os.path.join(os.path.dirname(landmark), 'data', filename) return open(path, mode) - + # Base test class class TestEmailBase(unittest.TestCase): def ndiffAssertEqual(self, first, second): @@ -69,7 +69,7 @@ class TestEmailBase(unittest.TestCase): return msg - + # Test various aspects of the Message class's API class TestMessageAPI(TestEmailBase): def test_get_all(self): @@ -504,7 +504,7 @@ class TestMessageAPI(TestEmailBase): self.assertEqual(msg.get_payload(decode=True), x) - + # Test the email.encoders module class TestEncoders(unittest.TestCase): def test_encode_empty_payload(self): @@ -531,7 +531,7 @@ class TestEncoders(unittest.TestCase): eq(msg['content-transfer-encoding'], 'quoted-printable') - + # Test long header wrapping class TestLongHeaders(TestEmailBase): def test_split_long_continuation(self): @@ -852,7 +852,7 @@ List: List-Unsubscribe: model->generator idempotency. IOW, read a message # in, parse it into a message object tree, then without touching the tree, # regenerate the plain text. The original text and the transformed text @@ -1896,7 +1896,7 @@ class TestIdempotent(TestEmailBase): eq(text, s.getvalue()) def test_parse_text_message(self): - eq = self.assertEquals + eq = self.assertEqual msg, text = self._msgobj('msg_01.txt') eq(msg.get_content_type(), 'text/plain') eq(msg.get_content_maintype(), 'text') @@ -1908,7 +1908,7 @@ class TestIdempotent(TestEmailBase): self._idempotent(msg, text) def test_parse_untyped_message(self): - eq = self.assertEquals + eq = self.assertEqual msg, text = self._msgobj('msg_03.txt') eq(msg.get_content_type(), 'text/plain') eq(msg.get_params(), None) @@ -1980,7 +1980,7 @@ class TestIdempotent(TestEmailBase): self._idempotent(msg, text) def test_content_type(self): - eq = self.assertEquals + eq = self.assertEqual unless = self.assertTrue # Get a message object and reset the seek pointer for other tests msg, text = self._msgobj('msg_05.txt') @@ -2012,7 +2012,7 @@ class TestIdempotent(TestEmailBase): eq(msg4.get_payload(), 'Yadda yadda yadda\n') def test_parser(self): - eq = self.assertEquals + eq = self.assertEqual unless = self.assertTrue msg, text = self._msgobj('msg_06.txt') # Check some of the outer headers @@ -2029,7 +2029,7 @@ class TestIdempotent(TestEmailBase): eq(msg1.get_payload(), '\n') - + # Test various other bits of the package's functionality class TestMiscellaneous(TestEmailBase): def test_message_from_string(self): @@ -2354,7 +2354,7 @@ multipart/report """) - + # Test the iterator/generators class TestIterators(TestEmailBase): def test_body_line_iterator(self): @@ -2414,7 +2414,7 @@ Do you like this message? """) - + class TestParsers(TestEmailBase): def test_header_parser(self): eq = self.assertEqual @@ -2559,7 +2559,7 @@ Here's the message body eq(msg.get_payload(), 'body') - + class TestBase64(unittest.TestCase): def test_len(self): eq = self.assertEqual @@ -2631,7 +2631,7 @@ eHh4eCB4eHh4IA==\r =?iso-8859-1?b?eHh4eCB4eHh4IHh4eHgg?=""") - + class TestQuopri(unittest.TestCase): def setUp(self): self.hlit = [chr(x) for x in range(ord('a'), ord('z')+1)] + \ @@ -2741,7 +2741,7 @@ one line two line""") - + # Test the Charset class class TestCharset(unittest.TestCase): def tearDown(self): @@ -2799,7 +2799,7 @@ class TestCharset(unittest.TestCase): self.assertRaises(errors.CharsetError, Charset, 'asc\xffii') - + # Test multilingual MIME headers. class TestHeader(TestEmailBase): def test_simple(self): @@ -2962,7 +2962,7 @@ A very long line that must get split to something other than at the raises(errors.HeaderParseError, decode_header, s) - + # Test RFC 2231 header parameters (en/de)coding class TestRFC2231(TestEmailBase): def test_get_param(self): @@ -3274,7 +3274,7 @@ Content-Type: application/x-foo; eq(s, 'My Document For You') - + def _testclasses(): mod = sys.modules[__name__] return [getattr(mod, name) for name in dir(mod) if name.startswith('Test')] @@ -3292,6 +3292,6 @@ def test_main(): run_unittest(testclass) - + if __name__ == '__main__': unittest.main(defaultTest='suite') diff --git a/Lib/json/tests/test_decode.py b/Lib/json/tests/test_decode.py index ca8f7b3..6afafe6 100644 --- a/Lib/json/tests/test_decode.py +++ b/Lib/json/tests/test_decode.py @@ -9,19 +9,19 @@ class TestDecode(TestCase): def test_decimal(self): rval = json.loads('1.1', parse_float=decimal.Decimal) self.assertTrue(isinstance(rval, decimal.Decimal)) - self.assertEquals(rval, decimal.Decimal('1.1')) + self.assertEqual(rval, decimal.Decimal('1.1')) def test_float(self): rval = json.loads('1', parse_int=float) self.assertTrue(isinstance(rval, float)) - self.assertEquals(rval, 1.0) + self.assertEqual(rval, 1.0) def test_decoder_optimizations(self): # Several optimizations were made that skip over calls to # the whitespace regex, so this test is designed to try and # exercise the uncommon cases. The array cases are already covered. rval = json.loads('{ "key" : "value" , "k":"v" }') - self.assertEquals(rval, {"key":"value", "k":"v"}) + self.assertEqual(rval, {"key":"value", "k":"v"}) def test_object_pairs_hook(self): s = '{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' diff --git a/Lib/json/tests/test_default.py b/Lib/json/tests/test_default.py index 49f05ad..6a03eeb 100644 --- a/Lib/json/tests/test_default.py +++ b/Lib/json/tests/test_default.py @@ -4,6 +4,6 @@ import json class TestDefault(TestCase): def test_default(self): - self.assertEquals( + self.assertEqual( json.dumps(type, default=repr), json.dumps(repr(type))) diff --git a/Lib/json/tests/test_dump.py b/Lib/json/tests/test_dump.py index 39875d5..89978e0 100644 --- a/Lib/json/tests/test_dump.py +++ b/Lib/json/tests/test_dump.py @@ -7,15 +7,15 @@ class TestDump(TestCase): def test_dump(self): sio = StringIO() json.dump({}, sio) - self.assertEquals(sio.getvalue(), '{}') + self.assertEqual(sio.getvalue(), '{}') def test_dumps(self): - self.assertEquals(json.dumps({}), '{}') + self.assertEqual(json.dumps({}), '{}') def test_encode_truefalse(self): - self.assertEquals(json.dumps( + self.assertEqual(json.dumps( {True: False, False: True}, sort_keys=True), '{"false": true, "true": false}') - self.assertEquals(json.dumps( + self.assertEqual(json.dumps( {2: 3.0, 4.0: 5L, False: 1, 6L: True}, sort_keys=True), '{"false": 1, "2": 3.0, "4.0": 5, "6": true}') diff --git a/Lib/json/tests/test_encode_basestring_ascii.py b/Lib/json/tests/test_encode_basestring_ascii.py index 02889f0..0e50110 100644 --- a/Lib/json/tests/test_encode_basestring_ascii.py +++ b/Lib/json/tests/test_encode_basestring_ascii.py @@ -36,7 +36,7 @@ class TestEncodeBaseStringAscii(TestCase): fname = encode_basestring_ascii.__name__ for input_string, expect in CASES: result = encode_basestring_ascii(input_string) - self.assertEquals(result, expect, + self.assertEqual(result, expect, '{0!r} != {1!r} for {2}({3!r})'.format( result, expect, fname, input_string)) diff --git a/Lib/json/tests/test_float.py b/Lib/json/tests/test_float.py index 15e7913..ec0cad1 100644 --- a/Lib/json/tests/test_float.py +++ b/Lib/json/tests/test_float.py @@ -7,13 +7,13 @@ class TestFloat(TestCase): def test_floats(self): for num in [1617161771.7650001, math.pi, math.pi**100, math.pi**-100, 3.1]: - self.assertEquals(float(json.dumps(num)), num) - self.assertEquals(json.loads(json.dumps(num)), num) - self.assertEquals(json.loads(unicode(json.dumps(num))), num) + self.assertEqual(float(json.dumps(num)), num) + self.assertEqual(json.loads(json.dumps(num)), num) + self.assertEqual(json.loads(unicode(json.dumps(num))), num) def test_ints(self): for num in [1, 1L, 1<<32, 1<<64]: - self.assertEquals(json.dumps(num), str(num)) - self.assertEquals(int(json.dumps(num)), num) - self.assertEquals(json.loads(json.dumps(num)), num) - self.assertEquals(json.loads(unicode(json.dumps(num))), num) + self.assertEqual(json.dumps(num), str(num)) + self.assertEqual(int(json.dumps(num)), num) + self.assertEqual(json.loads(json.dumps(num)), num) + self.assertEqual(json.loads(unicode(json.dumps(num))), num) diff --git a/Lib/json/tests/test_indent.py b/Lib/json/tests/test_indent.py index 6055162..cd608d9 100644 --- a/Lib/json/tests/test_indent.py +++ b/Lib/json/tests/test_indent.py @@ -36,6 +36,6 @@ class TestIndent(TestCase): h1 = json.loads(d1) h2 = json.loads(d2) - self.assertEquals(h1, h) - self.assertEquals(h2, h) - self.assertEquals(d2, expect) + self.assertEqual(h1, h) + self.assertEqual(h2, h) + self.assertEqual(d2, expect) diff --git a/Lib/json/tests/test_pass1.py b/Lib/json/tests/test_pass1.py index 216e252..719c113 100644 --- a/Lib/json/tests/test_pass1.py +++ b/Lib/json/tests/test_pass1.py @@ -67,7 +67,7 @@ class TestPass1(TestCase): # test in/out equivalence and parsing res = json.loads(JSON) out = json.dumps(res) - self.assertEquals(res, json.loads(out)) + self.assertEqual(res, json.loads(out)) try: json.dumps(res, allow_nan=False) except ValueError: diff --git a/Lib/json/tests/test_pass2.py b/Lib/json/tests/test_pass2.py index 80d8433..379117e 100644 --- a/Lib/json/tests/test_pass2.py +++ b/Lib/json/tests/test_pass2.py @@ -11,4 +11,4 @@ class TestPass2(TestCase): # test in/out equivalence and parsing res = json.loads(JSON) out = json.dumps(res) - self.assertEquals(res, json.loads(out)) + self.assertEqual(res, json.loads(out)) diff --git a/Lib/json/tests/test_pass3.py b/Lib/json/tests/test_pass3.py index 77d87b2..9151c43 100644 --- a/Lib/json/tests/test_pass3.py +++ b/Lib/json/tests/test_pass3.py @@ -17,4 +17,4 @@ class TestPass3(TestCase): # test in/out equivalence and parsing res = json.loads(JSON) out = json.dumps(res) - self.assertEquals(res, json.loads(out)) + self.assertEqual(res, json.loads(out)) diff --git a/Lib/json/tests/test_recursion.py b/Lib/json/tests/test_recursion.py index 073d3c1..1e9b8ab 100644 --- a/Lib/json/tests/test_recursion.py +++ b/Lib/json/tests/test_recursion.py @@ -57,7 +57,7 @@ class TestRecursion(TestCase): def test_defaultrecursion(self): enc = RecursiveJSONEncoder() - self.assertEquals(enc.encode(JSONTestObject), '"JSONTestObject"') + self.assertEqual(enc.encode(JSONTestObject), '"JSONTestObject"') enc.recurse = True try: enc.encode(JSONTestObject) diff --git a/Lib/json/tests/test_scanstring.py b/Lib/json/tests/test_scanstring.py index 53d0b66..bf3ccd5 100644 --- a/Lib/json/tests/test_scanstring.py +++ b/Lib/json/tests/test_scanstring.py @@ -13,92 +13,92 @@ class TestScanString(TestCase): self._test_scanstring(json.decoder.c_scanstring) def _test_scanstring(self, scanstring): - self.assertEquals( + self.assertEqual( scanstring('"z\\ud834\\udd20x"', 1, None, True), (u'z\U0001d120x', 16)) if sys.maxunicode == 65535: - self.assertEquals( + self.assertEqual( scanstring(u'"z\U0001d120x"', 1, None, True), (u'z\U0001d120x', 6)) else: - self.assertEquals( + self.assertEqual( scanstring(u'"z\U0001d120x"', 1, None, True), (u'z\U0001d120x', 5)) - self.assertEquals( + self.assertEqual( scanstring('"\\u007b"', 1, None, True), (u'{', 8)) - self.assertEquals( + self.assertEqual( scanstring('"A JSON payload should be an object or array, not a string."', 1, None, True), (u'A JSON payload should be an object or array, not a string.', 60)) - self.assertEquals( + self.assertEqual( scanstring('["Unclosed array"', 2, None, True), (u'Unclosed array', 17)) - self.assertEquals( + self.assertEqual( scanstring('["extra comma",]', 2, None, True), (u'extra comma', 14)) - self.assertEquals( + self.assertEqual( scanstring('["double extra comma",,]', 2, None, True), (u'double extra comma', 21)) - self.assertEquals( + self.assertEqual( scanstring('["Comma after the close"],', 2, None, True), (u'Comma after the close', 24)) - self.assertEquals( + self.assertEqual( scanstring('["Extra close"]]', 2, None, True), (u'Extra close', 14)) - self.assertEquals( + self.assertEqual( scanstring('{"Extra comma": true,}', 2, None, True), (u'Extra comma', 14)) - self.assertEquals( + self.assertEqual( scanstring('{"Extra value after close": true} "misplaced quoted value"', 2, None, True), (u'Extra value after close', 26)) - self.assertEquals( + self.assertEqual( scanstring('{"Illegal expression": 1 + 2}', 2, None, True), (u'Illegal expression', 21)) - self.assertEquals( + self.assertEqual( scanstring('{"Illegal invocation": alert()}', 2, None, True), (u'Illegal invocation', 21)) - self.assertEquals( + self.assertEqual( scanstring('{"Numbers cannot have leading zeroes": 013}', 2, None, True), (u'Numbers cannot have leading zeroes', 37)) - self.assertEquals( + self.assertEqual( scanstring('{"Numbers cannot be hex": 0x14}', 2, None, True), (u'Numbers cannot be hex', 24)) - self.assertEquals( + self.assertEqual( scanstring('[[[[[[[[[[[[[[[[[[[["Too deep"]]]]]]]]]]]]]]]]]]]]', 21, None, True), (u'Too deep', 30)) - self.assertEquals( + self.assertEqual( scanstring('{"Missing colon" null}', 2, None, True), (u'Missing colon', 16)) - self.assertEquals( + self.assertEqual( scanstring('{"Double colon":: null}', 2, None, True), (u'Double colon', 15)) - self.assertEquals( + self.assertEqual( scanstring('{"Comma instead of colon", null}', 2, None, True), (u'Comma instead of colon', 25)) - self.assertEquals( + self.assertEqual( scanstring('["Colon instead of comma": false]', 2, None, True), (u'Colon instead of comma', 25)) - self.assertEquals( + self.assertEqual( scanstring('["Bad value", truth]', 2, None, True), (u'Bad value', 12)) diff --git a/Lib/json/tests/test_separators.py b/Lib/json/tests/test_separators.py index 32db341..d5b92bd 100644 --- a/Lib/json/tests/test_separators.py +++ b/Lib/json/tests/test_separators.py @@ -37,6 +37,6 @@ class TestSeparators(TestCase): h1 = json.loads(d1) h2 = json.loads(d2) - self.assertEquals(h1, h) - self.assertEquals(h2, h) - self.assertEquals(d2, expect) + self.assertEqual(h1, h) + self.assertEqual(h2, h) + self.assertEqual(d2, expect) diff --git a/Lib/json/tests/test_speedups.py b/Lib/json/tests/test_speedups.py index 3f8c108..3b4ccb3 100644 --- a/Lib/json/tests/test_speedups.py +++ b/Lib/json/tests/test_speedups.py @@ -5,11 +5,11 @@ from json import decoder, encoder, scanner class TestSpeedups(TestCase): def test_scanstring(self): - self.assertEquals(decoder.scanstring.__module__, "_json") + self.assertEqual(decoder.scanstring.__module__, "_json") self.assertTrue(decoder.scanstring is decoder.c_scanstring) def test_encode_basestring_ascii(self): - self.assertEquals(encoder.encode_basestring_ascii.__module__, "_json") + self.assertEqual(encoder.encode_basestring_ascii.__module__, "_json") self.assertTrue(encoder.encode_basestring_ascii is encoder.c_encode_basestring_ascii) diff --git a/Lib/json/tests/test_unicode.py b/Lib/json/tests/test_unicode.py index 6aaed3f..ad7fe24 100644 --- a/Lib/json/tests/test_unicode.py +++ b/Lib/json/tests/test_unicode.py @@ -10,50 +10,50 @@ class TestUnicode(TestCase): s = u.encode('utf-8') ju = encoder.encode(u) js = encoder.encode(s) - self.assertEquals(ju, js) + self.assertEqual(ju, js) def test_encoding2(self): u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' s = u.encode('utf-8') ju = json.dumps(u, encoding='utf-8') js = json.dumps(s, encoding='utf-8') - self.assertEquals(ju, js) + self.assertEqual(ju, js) def test_encoding3(self): u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps(u) - self.assertEquals(j, '"\\u03b1\\u03a9"') + self.assertEqual(j, '"\\u03b1\\u03a9"') def test_encoding4(self): u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps([u]) - self.assertEquals(j, '["\\u03b1\\u03a9"]') + self.assertEqual(j, '["\\u03b1\\u03a9"]') def test_encoding5(self): u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps(u, ensure_ascii=False) - self.assertEquals(j, u'"{0}"'.format(u)) + self.assertEqual(j, u'"{0}"'.format(u)) def test_encoding6(self): u = u'\N{GREEK SMALL LETTER ALPHA}\N{GREEK CAPITAL LETTER OMEGA}' j = json.dumps([u], ensure_ascii=False) - self.assertEquals(j, u'["{0}"]'.format(u)) + self.assertEqual(j, u'["{0}"]'.format(u)) def test_big_unicode_encode(self): u = u'\U0001d120' - self.assertEquals(json.dumps(u), '"\\ud834\\udd20"') - self.assertEquals(json.dumps(u, ensure_ascii=False), u'"\U0001d120"') + self.assertEqual(json.dumps(u), '"\\ud834\\udd20"') + self.assertEqual(json.dumps(u, ensure_ascii=False), u'"\U0001d120"') def test_big_unicode_decode(self): u = u'z\U0001d120x' - self.assertEquals(json.loads('"' + u + '"'), u) - self.assertEquals(json.loads('"z\\ud834\\udd20x"'), u) + self.assertEqual(json.loads('"' + u + '"'), u) + self.assertEqual(json.loads('"z\\ud834\\udd20x"'), u) def test_unicode_decode(self): for i in range(0, 0xd7ff): u = unichr(i) s = '"\\u{0:04x}"'.format(i) - self.assertEquals(json.loads(s), u) + self.assertEqual(json.loads(s), u) def test_object_pairs_hook_with_unicode(self): s = u'{"xkd":1, "kcw":2, "art":3, "hxm":4, "qrt":5, "pad":6, "hoy":7}' @@ -71,12 +71,12 @@ class TestUnicode(TestCase): OrderedDict(p)) def test_default_encoding(self): - self.assertEquals(json.loads(u'{"a": "\xe9"}'.encode('utf-8')), + self.assertEqual(json.loads(u'{"a": "\xe9"}'.encode('utf-8')), {'a': u'\xe9'}) def test_unicode_preservation(self): - self.assertEquals(type(json.loads(u'""')), unicode) - self.assertEquals(type(json.loads(u'"a"')), unicode) - self.assertEquals(type(json.loads(u'["a"]')[0]), unicode) + self.assertEqual(type(json.loads(u'""')), unicode) + self.assertEqual(type(json.loads(u'"a"')), unicode) + self.assertEqual(type(json.loads(u'["a"]')[0]), unicode) # Issue 10038. - self.assertEquals(type(json.loads('"foo"')), unicode) + self.assertEqual(type(json.loads('"foo"')), unicode) diff --git a/Lib/sqlite3/test/dbapi.py b/Lib/sqlite3/test/dbapi.py index 401ba79..6701c22 100644 --- a/Lib/sqlite3/test/dbapi.py +++ b/Lib/sqlite3/test/dbapi.py @@ -44,8 +44,8 @@ class ModuleTests(unittest.TestCase): sqlite.paramstyle) def CheckWarning(self): - self.assert_(issubclass(sqlite.Warning, StandardError), - "Warning is not a subclass of StandardError") + self.assertTrue(issubclass(sqlite.Warning, StandardError), + "Warning is not a subclass of StandardError") def CheckError(self): self.assertTrue(issubclass(sqlite.Error, StandardError), diff --git a/Lib/sqlite3/test/types.py b/Lib/sqlite3/test/types.py index 70d20dc..c5ab39b 100644 --- a/Lib/sqlite3/test/types.py +++ b/Lib/sqlite3/test/types.py @@ -306,7 +306,7 @@ class ColNamesTests(unittest.TestCase): no row returned. """ self.cur.execute("select * from test where 0 = 1") - self.assert_(self.cur.description[0][0] == "x") + self.assertEqual(self.cur.description[0][0], "x") class ObjectAdaptationTests(unittest.TestCase): def cast(obj): diff --git a/Lib/test/buffer_tests.py b/Lib/test/buffer_tests.py index db27759..d0d8a56 100644 --- a/Lib/test/buffer_tests.py +++ b/Lib/test/buffer_tests.py @@ -15,32 +15,32 @@ class MixinBytesBufferCommonTests(object): def test_islower(self): self.assertFalse(self.marshal(b'').islower()) - self.assert_(self.marshal(b'a').islower()) + self.assertTrue(self.marshal(b'a').islower()) self.assertFalse(self.marshal(b'A').islower()) self.assertFalse(self.marshal(b'\n').islower()) - self.assert_(self.marshal(b'abc').islower()) + self.assertTrue(self.marshal(b'abc').islower()) self.assertFalse(self.marshal(b'aBc').islower()) - self.assert_(self.marshal(b'abc\n').islower()) + self.assertTrue(self.marshal(b'abc\n').islower()) self.assertRaises(TypeError, self.marshal(b'abc').islower, 42) def test_isupper(self): self.assertFalse(self.marshal(b'').isupper()) self.assertFalse(self.marshal(b'a').isupper()) - self.assert_(self.marshal(b'A').isupper()) + self.assertTrue(self.marshal(b'A').isupper()) self.assertFalse(self.marshal(b'\n').isupper()) - self.assert_(self.marshal(b'ABC').isupper()) + self.assertTrue(self.marshal(b'ABC').isupper()) self.assertFalse(self.marshal(b'AbC').isupper()) - self.assert_(self.marshal(b'ABC\n').isupper()) + self.assertTrue(self.marshal(b'ABC\n').isupper()) self.assertRaises(TypeError, self.marshal(b'abc').isupper, 42) def test_istitle(self): self.assertFalse(self.marshal(b'').istitle()) self.assertFalse(self.marshal(b'a').istitle()) - self.assert_(self.marshal(b'A').istitle()) + self.assertTrue(self.marshal(b'A').istitle()) self.assertFalse(self.marshal(b'\n').istitle()) - self.assert_(self.marshal(b'A Titlecased Line').istitle()) - self.assert_(self.marshal(b'A\nTitlecased Line').istitle()) - self.assert_(self.marshal(b'A Titlecased, Line').istitle()) + self.assertTrue(self.marshal(b'A Titlecased Line').istitle()) + self.assertTrue(self.marshal(b'A\nTitlecased Line').istitle()) + self.assertTrue(self.marshal(b'A Titlecased, Line').istitle()) self.assertFalse(self.marshal(b'Not a capitalized String').istitle()) self.assertFalse(self.marshal(b'Not\ta Titlecase String').istitle()) self.assertFalse(self.marshal(b'Not--a Titlecase String').istitle()) @@ -50,31 +50,31 @@ class MixinBytesBufferCommonTests(object): def test_isspace(self): self.assertFalse(self.marshal(b'').isspace()) self.assertFalse(self.marshal(b'a').isspace()) - self.assert_(self.marshal(b' ').isspace()) - self.assert_(self.marshal(b'\t').isspace()) - self.assert_(self.marshal(b'\r').isspace()) - self.assert_(self.marshal(b'\n').isspace()) - self.assert_(self.marshal(b' \t\r\n').isspace()) + self.assertTrue(self.marshal(b' ').isspace()) + self.assertTrue(self.marshal(b'\t').isspace()) + self.assertTrue(self.marshal(b'\r').isspace()) + self.assertTrue(self.marshal(b'\n').isspace()) + self.assertTrue(self.marshal(b' \t\r\n').isspace()) self.assertFalse(self.marshal(b' \t\r\na').isspace()) self.assertRaises(TypeError, self.marshal(b'abc').isspace, 42) def test_isalpha(self): self.assertFalse(self.marshal(b'').isalpha()) - self.assert_(self.marshal(b'a').isalpha()) - self.assert_(self.marshal(b'A').isalpha()) + self.assertTrue(self.marshal(b'a').isalpha()) + self.assertTrue(self.marshal(b'A').isalpha()) self.assertFalse(self.marshal(b'\n').isalpha()) - self.assert_(self.marshal(b'abc').isalpha()) + self.assertTrue(self.marshal(b'abc').isalpha()) self.assertFalse(self.marshal(b'aBc123').isalpha()) self.assertFalse(self.marshal(b'abc\n').isalpha()) self.assertRaises(TypeError, self.marshal(b'abc').isalpha, 42) def test_isalnum(self): self.assertFalse(self.marshal(b'').isalnum()) - self.assert_(self.marshal(b'a').isalnum()) - self.assert_(self.marshal(b'A').isalnum()) + self.assertTrue(self.marshal(b'a').isalnum()) + self.assertTrue(self.marshal(b'A').isalnum()) self.assertFalse(self.marshal(b'\n').isalnum()) - self.assert_(self.marshal(b'123abc456').isalnum()) - self.assert_(self.marshal(b'a1b3c').isalnum()) + self.assertTrue(self.marshal(b'123abc456').isalnum()) + self.assertTrue(self.marshal(b'a1b3c').isalnum()) self.assertFalse(self.marshal(b'aBc000 ').isalnum()) self.assertFalse(self.marshal(b'abc\n').isalnum()) self.assertRaises(TypeError, self.marshal(b'abc').isalnum, 42) @@ -82,8 +82,8 @@ class MixinBytesBufferCommonTests(object): def test_isdigit(self): self.assertFalse(self.marshal(b'').isdigit()) self.assertFalse(self.marshal(b'a').isdigit()) - self.assert_(self.marshal(b'0').isdigit()) - self.assert_(self.marshal(b'0123456789').isdigit()) + self.assertTrue(self.marshal(b'0').isdigit()) + self.assertTrue(self.marshal(b'0123456789').isdigit()) self.assertFalse(self.marshal(b'0123456789a').isdigit()) self.assertRaises(TypeError, self.marshal(b'abc').isdigit, 42) diff --git a/Lib/test/fork_wait.py b/Lib/test/fork_wait.py index cc51f89..2646cbd 100644 --- a/Lib/test/fork_wait.py +++ b/Lib/test/fork_wait.py @@ -43,8 +43,8 @@ class ForkWait(unittest.TestCase): break time.sleep(2 * SHORTSLEEP) - self.assertEquals(spid, cpid) - self.assertEquals(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8)) + self.assertEqual(spid, cpid) + self.assertEqual(status, 0, "cause = %d, exit = %d" % (status&0xff, status>>8)) def test_wait(self): for i in range(NUM_THREADS): @@ -54,7 +54,7 @@ class ForkWait(unittest.TestCase): a = self.alive.keys() a.sort() - self.assertEquals(a, range(NUM_THREADS)) + self.assertEqual(a, range(NUM_THREADS)) prefork_lives = self.alive.copy() diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py index 546416e..b8d6d6b 100644 --- a/Lib/test/list_tests.py +++ b/Lib/test/list_tests.py @@ -330,7 +330,7 @@ class CommonTest(seq_tests.CommonTest): self.assertRaises(BadExc, d.remove, 'c') for x, y in zip(d, e): # verify that original order and values are retained. - self.assert_(x is y) + self.assertIs(x, y) def test_count(self): a = self.type2test([0, 1, 2])*3 @@ -466,7 +466,7 @@ class CommonTest(seq_tests.CommonTest): u = self.type2test([0, 1]) u2 = u u += [2, 3] - self.assert_(u is u2) + self.assertIs(u, u2) u = self.type2test("spam") u += "eggs" diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py index cf3ae8e..f5e4e0e 100644 --- a/Lib/test/seq_tests.py +++ b/Lib/test/seq_tests.py @@ -131,8 +131,8 @@ class CommonTest(unittest.TestCase): self.assertRaises(ZeroDivisionError, self.type2test, IterGenExc(s)) def test_truth(self): - self.assert_(not self.type2test()) - self.assert_(self.type2test([42])) + self.assertFalse(self.type2test()) + self.assertTrue(self.type2test([42])) def test_getitem(self): u = self.type2test([0, 1, 2, 3, 4]) @@ -270,7 +270,7 @@ class CommonTest(unittest.TestCase): pass u3 = subclass([0, 1]) self.assertEqual(u3, u3*1) - self.assert_(u3 is not u3*1) + self.assertIsNot(u3, u3*1) def test_iadd(self): u = self.type2test([0, 1]) diff --git a/Lib/test/string_tests.py b/Lib/test/string_tests.py index eb5132e..546b486 100644 --- a/Lib/test/string_tests.py +++ b/Lib/test/string_tests.py @@ -62,7 +62,7 @@ class CommonTest(unittest.TestCase): pass object = subtype(object) realresult = getattr(object, methodname)(*args) - self.assert_(object is not realresult) + self.assertTrue(object is not realresult) # check that object.method(*args) raises exc def checkraises(self, exc, object, methodname, *args): @@ -1243,34 +1243,34 @@ class MixinStrUnicodeTest: pass s1 = subclass("abcd") s2 = t().join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is t) s1 = t("abcd") s2 = t().join([s1]) - self.assert_(s1 is s2) + self.assertTrue(s1 is s2) # Should also test mixed-type join. if t is unicode: s1 = subclass("abcd") s2 = "".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is t) + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is t) s1 = t("abcd") s2 = "".join([s1]) - self.assert_(s1 is s2) + self.assertTrue(s1 is s2) elif t is str: s1 = subclass("abcd") s2 = u"".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is unicode) # promotes! + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is unicode) # promotes! s1 = t("abcd") s2 = u"".join([s1]) - self.assert_(s1 is not s2) - self.assert_(type(s2) is unicode) # promotes! + self.assertTrue(s1 is not s2) + self.assertTrue(type(s2) is unicode) # promotes! else: self.fail("unexpected type for MixinStrUnicodeTest %r" % t) diff --git a/Lib/test/test_SimpleHTTPServer.py b/Lib/test/test_SimpleHTTPServer.py index 9d3ad16..66ec853 100644 --- a/Lib/test/test_SimpleHTTPServer.py +++ b/Lib/test/test_SimpleHTTPServer.py @@ -21,17 +21,17 @@ class SimpleHTTPRequestHandlerTestCase(unittest.TestCase): def test_queryArguments (self): path = self.handler.translate_path ('/filename') - self.assertEquals (path, self.translated) + self.assertEqual (path, self.translated) path = self.handler.translate_path ('/filename?foo=bar') - self.assertEquals (path, self.translated) + self.assertEqual (path, self.translated) path = self.handler.translate_path ('/filename?a=b&spam=eggs#zot') - self.assertEquals (path, self.translated) + self.assertEqual (path, self.translated) def test_startWithDoubleSlash (self): path = self.handler.translate_path ('//filename') - self.assertEquals (path, self.translated) + self.assertEqual (path, self.translated) path = self.handler.translate_path ('//filename?foo=bar') - self.assertEquals (path, self.translated) + self.assertEqual (path, self.translated) def test_main(): diff --git a/Lib/test/test__locale.py b/Lib/test/test__locale.py index 2fc128f..afcb926 100644 --- a/Lib/test/test__locale.py +++ b/Lib/test/test__locale.py @@ -59,7 +59,7 @@ class _LocaleTests(unittest.TestCase): known_value = known_numerics.get(used_locale, ('', ''))[data_type == 'thousands_sep'] if known_value and calc_value: - self.assertEquals(calc_value, known_value, + self.assertEqual(calc_value, known_value, self.lc_numeric_err_msg % ( calc_value, known_value, calc_type, data_type, set_locale, @@ -103,7 +103,7 @@ class _LocaleTests(unittest.TestCase): set_locale = setlocale(LC_NUMERIC) except Error: set_locale = "" - self.assertEquals(nl_radixchar, li_radixchar, + self.assertEqual(nl_radixchar, li_radixchar, "%s (nl_langinfo) != %s (localeconv) " "(set to %s, using %s)" % ( nl_radixchar, li_radixchar, @@ -122,9 +122,9 @@ class _LocaleTests(unittest.TestCase): if loc == 'eu_ES' and localeconv()['decimal_point'] == "' ": continue - self.assertEquals(int(eval('3.14') * 100), 314, + self.assertEqual(int(eval('3.14') * 100), 314, "using eval('3.14') failed for %s" % loc) - self.assertEquals(int(float('3.14') * 100), 314, + self.assertEqual(int(float('3.14') * 100), 314, "using float('3.14') failed for %s" % loc) if localeconv()['decimal_point'] != '.': self.assertRaises(ValueError, float, diff --git a/Lib/test/test_argparse.py b/Lib/test/test_argparse.py index 17f4bb4..3e71f57 100644 --- a/Lib/test/test_argparse.py +++ b/Lib/test/test_argparse.py @@ -2709,18 +2709,18 @@ class TestNamespaceContainsSimple(TestCase): def test_empty(self): ns = argparse.Namespace() - self.assertEquals('' in ns, False) - self.assertEquals('' not in ns, True) - self.assertEquals('x' in ns, False) + self.assertEqual('' in ns, False) + self.assertEqual('' not in ns, True) + self.assertEqual('x' in ns, False) def test_non_empty(self): ns = argparse.Namespace(x=1, y=2) - self.assertEquals('x' in ns, True) - self.assertEquals('x' not in ns, False) - self.assertEquals('y' in ns, True) - self.assertEquals('' in ns, False) - self.assertEquals('xx' in ns, False) - self.assertEquals('z' in ns, False) + self.assertEqual('x' in ns, True) + self.assertEqual('x' not in ns, False) + self.assertEqual('y' in ns, True) + self.assertEqual('' in ns, False) + self.assertEqual('xx' in ns, False) + self.assertEqual('z' in ns, False) # ===================== # Help formatting tests diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py index a4aeccf..4d56f54 100755 --- a/Lib/test/test_array.py +++ b/Lib/test/test_array.py @@ -628,11 +628,11 @@ class BaseTest(unittest.TestCase): data.reverse() L[start:stop:step] = data a[start:stop:step] = array.array(self.typecode, data) - self.assertEquals(a, array.array(self.typecode, L)) + self.assertEqual(a, array.array(self.typecode, L)) del L[start:stop:step] del a[start:stop:step] - self.assertEquals(a, array.array(self.typecode, L)) + self.assertEqual(a, array.array(self.typecode, L)) def test_index(self): example = 2*self.example diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py index 2ee9d2a..05ce09e 100644 --- a/Lib/test/test_ast.py +++ b/Lib/test/test_ast.py @@ -147,7 +147,7 @@ class AST_Tests(unittest.TestCase): (eval_tests, eval_results, "eval")): for i, o in itertools.izip(input, output): ast_tree = compile(i, "?", kind, ast.PyCF_ONLY_AST) - self.assertEquals(to_tuple(ast_tree), o) + self.assertEqual(to_tuple(ast_tree), o) self._assertTrueorder(ast_tree, (0, 0)) def test_slice(self): @@ -171,20 +171,20 @@ class AST_Tests(unittest.TestCase): def test_nodeclasses(self): x = ast.BinOp(1, 2, 3, lineno=0) - self.assertEquals(x.left, 1) - self.assertEquals(x.op, 2) - self.assertEquals(x.right, 3) - self.assertEquals(x.lineno, 0) + self.assertEqual(x.left, 1) + self.assertEqual(x.op, 2) + self.assertEqual(x.right, 3) + self.assertEqual(x.lineno, 0) # node raises exception when not given enough arguments self.assertRaises(TypeError, ast.BinOp, 1, 2) # can set attributes through kwargs too x = ast.BinOp(left=1, op=2, right=3, lineno=0) - self.assertEquals(x.left, 1) - self.assertEquals(x.op, 2) - self.assertEquals(x.right, 3) - self.assertEquals(x.lineno, 0) + self.assertEqual(x.left, 1) + self.assertEqual(x.op, 2) + self.assertEqual(x.right, 3) + self.assertEqual(x.lineno, 0) # this used to fail because Sub._fields was None x = ast.Sub() @@ -202,7 +202,7 @@ class AST_Tests(unittest.TestCase): for protocol in protocols: for ast in (compile(i, "?", "exec", 0x400) for i in exec_tests): ast2 = mod.loads(mod.dumps(ast, protocol)) - self.assertEquals(to_tuple(ast2), to_tuple(ast)) + self.assertEqual(to_tuple(ast2), to_tuple(ast)) class ASTHelpers_Test(unittest.TestCase): diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py index 0292a95..059e8b7 100644 --- a/Lib/test/test_augassign.py +++ b/Lib/test/test_augassign.py @@ -19,10 +19,10 @@ class AugAssignTest(unittest.TestCase): x /= 2 if 1/2 == 0: # classic division - self.assertEquals(x, 3) + self.assertEqual(x, 3) else: # new-style division (with -Qnew) - self.assertEquals(x, 3.0) + self.assertEqual(x, 3.0) def test_with_unpacking(self): self.assertRaises(SyntaxError, compile, "x, b += 3", "", "exec") @@ -40,9 +40,9 @@ class AugAssignTest(unittest.TestCase): x[0] ^= 1 x[0] /= 2 if 1/2 == 0: - self.assertEquals(x[0], 3) + self.assertEqual(x[0], 3) else: - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testInDict(self): x = {0: 2} @@ -57,23 +57,23 @@ class AugAssignTest(unittest.TestCase): x[0] ^= 1 x[0] /= 2 if 1/2 == 0: - self.assertEquals(x[0], 3) + self.assertEqual(x[0], 3) else: - self.assertEquals(x[0], 3.0) + self.assertEqual(x[0], 3.0) def testSequences(self): x = [1,2] x += [3,4] x *= 2 - self.assertEquals(x, [1, 2, 3, 4, 1, 2, 3, 4]) + self.assertEqual(x, [1, 2, 3, 4, 1, 2, 3, 4]) x = [1, 2, 3] y = x x[1:2] *= 2 y[1:2] += [1] - self.assertEquals(x, [1, 2, 1, 2, 3]) + self.assertEqual(x, [1, 2, 1, 2, 3]) self.assertTrue(x is y) def testCustomMethods1(self): @@ -101,14 +101,14 @@ class AugAssignTest(unittest.TestCase): self.assertIsInstance(x, aug_test) self.assertTrue(y is not x) - self.assertEquals(x.val, 11) + self.assertEqual(x.val, 11) x = aug_test2(2) y = x x += 10 self.assertTrue(y is x) - self.assertEquals(x.val, 12) + self.assertEqual(x.val, 12) x = aug_test3(3) y = x @@ -116,7 +116,7 @@ class AugAssignTest(unittest.TestCase): self.assertIsInstance(x, aug_test3) self.assertTrue(y is not x) - self.assertEquals(x.val, 13) + self.assertEqual(x.val, 13) def testCustomMethods2(test_self): @@ -284,7 +284,7 @@ class AugAssignTest(unittest.TestCase): 1 << x x <<= 1 - test_self.assertEquals(output, '''\ + test_self.assertEqual(output, '''\ __add__ called __radd__ called __iadd__ called diff --git a/Lib/test/test_bigaddrspace.py b/Lib/test/test_bigaddrspace.py index 8c215fe..db19a53 100644 --- a/Lib/test/test_bigaddrspace.py +++ b/Lib/test/test_bigaddrspace.py @@ -28,7 +28,7 @@ class StrTest(unittest.TestCase): pass else: self.fail("should have raised OverflowError") - self.assertEquals(len(x), MAX_Py_ssize_t) + self.assertEqual(len(x), MAX_Py_ssize_t) ### the following test is pending a patch # (http://mail.python.org/pipermail/python-dev/2006-July/067774.html) diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py index 1f7fd6a..c560167 100644 --- a/Lib/test/test_bigmem.py +++ b/Lib/test/test_bigmem.py @@ -13,7 +13,7 @@ import sys # doesn't release the old 's' (if it exists) until well after its new # value has been created. Use 'del s' before the create_largestring call. # -# - Do *not* compare large objects using assertEquals or similar. It's a +# - Do *not* compare large objects using assertEqual or similar. It's a # lengty operation and the errormessage will be utterly useless due to # its size. To make sure whether a result has the right contents, better # to use the strip or count methods, or compare meaningful slices. @@ -39,20 +39,20 @@ class StrTest(unittest.TestCase): SUBSTR = ' abc def ghi' s = '-' * size + SUBSTR caps = s.capitalize() - self.assertEquals(caps[-len(SUBSTR):], + self.assertEqual(caps[-len(SUBSTR):], SUBSTR.capitalize()) - self.assertEquals(caps.lstrip('-'), SUBSTR) + self.assertEqual(caps.lstrip('-'), SUBSTR) @bigmemtest(minsize=_2G + 10, memuse=1) def test_center(self, size): SUBSTR = ' abc def ghi' s = SUBSTR.center(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2 if len(s) % 2: lpadsize += 1 - self.assertEquals(s[lpadsize:-rpadsize], SUBSTR) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) + self.assertEqual(s.strip(), SUBSTR.strip()) @precisionbigmemtest(size=_2G - 1, memuse=1) def test_center_unicode(self, size): @@ -62,36 +62,36 @@ class StrTest(unittest.TestCase): except OverflowError: pass # acceptable on 32-bit else: - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) lpadsize = rpadsize = (len(s) - len(SUBSTR)) // 2 if len(s) % 2: lpadsize += 1 - self.assertEquals(s[lpadsize:-rpadsize], SUBSTR) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(s[lpadsize:-rpadsize], SUBSTR) + self.assertEqual(s.strip(), SUBSTR.strip()) del s @bigmemtest(minsize=_2G, memuse=2) def test_count(self, size): SUBSTR = ' abc def ghi' s = '.' * size + SUBSTR - self.assertEquals(s.count('.'), size) + self.assertEqual(s.count('.'), size) s += '.' - self.assertEquals(s.count('.'), size + 1) - self.assertEquals(s.count(' '), 3) - self.assertEquals(s.count('i'), 1) - self.assertEquals(s.count('j'), 0) + self.assertEqual(s.count('.'), size + 1) + self.assertEqual(s.count(' '), 3) + self.assertEqual(s.count('i'), 1) + self.assertEqual(s.count('j'), 0) @bigmemtest(minsize=_2G + 2, memuse=3) def test_decode(self, size): s = '.' * size - self.assertEquals(len(s.decode('utf-8')), size) + self.assertEqual(len(s.decode('utf-8')), size) def basic_encode_test(self, size, enc, c=u'.', expectedsize=None): if expectedsize is None: expectedsize = size s = c * size - self.assertEquals(len(s.encode(enc)), expectedsize) + self.assertEqual(len(s.encode(enc)), expectedsize) @bigmemtest(minsize=_2G + 2, memuse=3) def test_encode(self, size): @@ -147,43 +147,43 @@ class StrTest(unittest.TestCase): def test_expandtabs(self, size): s = '-' * size tabsize = 8 - self.assertEquals(s.expandtabs(), s) + self.assertEqual(s.expandtabs(), s) del s slen, remainder = divmod(size, tabsize) s = ' \t' * slen s = s.expandtabs(tabsize) - self.assertEquals(len(s), size - remainder) - self.assertEquals(len(s.strip(' ')), 0) + self.assertEqual(len(s), size - remainder) + self.assertEqual(len(s.strip(' ')), 0) @bigmemtest(minsize=_2G, memuse=2) def test_find(self, size): SUBSTR = ' abc def ghi' sublen = len(SUBSTR) s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEquals(s.find(' '), 0) - self.assertEquals(s.find(SUBSTR), 0) - self.assertEquals(s.find(' ', sublen), sublen + size) - self.assertEquals(s.find(SUBSTR, len(SUBSTR)), sublen + size) - self.assertEquals(s.find('i'), SUBSTR.find('i')) - self.assertEquals(s.find('i', sublen), + self.assertEqual(s.find(' '), 0) + self.assertEqual(s.find(SUBSTR), 0) + self.assertEqual(s.find(' ', sublen), sublen + size) + self.assertEqual(s.find(SUBSTR, len(SUBSTR)), sublen + size) + self.assertEqual(s.find('i'), SUBSTR.find('i')) + self.assertEqual(s.find('i', sublen), sublen + size + SUBSTR.find('i')) - self.assertEquals(s.find('i', size), + self.assertEqual(s.find('i', size), sublen + size + SUBSTR.find('i')) - self.assertEquals(s.find('j'), -1) + self.assertEqual(s.find('j'), -1) @bigmemtest(minsize=_2G, memuse=2) def test_index(self, size): SUBSTR = ' abc def ghi' sublen = len(SUBSTR) s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEquals(s.index(' '), 0) - self.assertEquals(s.index(SUBSTR), 0) - self.assertEquals(s.index(' ', sublen), sublen + size) - self.assertEquals(s.index(SUBSTR, sublen), sublen + size) - self.assertEquals(s.index('i'), SUBSTR.index('i')) - self.assertEquals(s.index('i', sublen), + self.assertEqual(s.index(' '), 0) + self.assertEqual(s.index(SUBSTR), 0) + self.assertEqual(s.index(' ', sublen), sublen + size) + self.assertEqual(s.index(SUBSTR, sublen), sublen + size) + self.assertEqual(s.index('i'), SUBSTR.index('i')) + self.assertEqual(s.index('i', sublen), sublen + size + SUBSTR.index('i')) - self.assertEquals(s.index('i', size), + self.assertEqual(s.index('i', size), sublen + size + SUBSTR.index('i')) self.assertRaises(ValueError, s.index, 'j') @@ -252,8 +252,8 @@ class StrTest(unittest.TestCase): def test_join(self, size): s = 'A' * size x = s.join(['aaaaa', 'bbbbb']) - self.assertEquals(x.count('a'), 5) - self.assertEquals(x.count('b'), 5) + self.assertEqual(x.count('a'), 5) + self.assertEqual(x.count('b'), 5) self.assertTrue(x.startswith('aaaaaA')) self.assertTrue(x.endswith('Abbbbb')) @@ -262,25 +262,25 @@ class StrTest(unittest.TestCase): SUBSTR = ' abc def ghi' s = SUBSTR.ljust(size) self.assertTrue(s.startswith(SUBSTR + ' ')) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G + 10, memuse=2) def test_lower(self, size): s = 'A' * size s = s.lower() - self.assertEquals(len(s), size) - self.assertEquals(s.count('a'), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count('a'), size) @bigmemtest(minsize=_2G + 10, memuse=1) def test_lstrip(self, size): SUBSTR = 'abc def ghi' s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.lstrip(), SUBSTR.lstrip()) + self.assertEqual(len(s), size) + self.assertEqual(s.lstrip(), SUBSTR.lstrip()) del s s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) stripped = s.lstrip() self.assertTrue(stripped is s) @@ -289,44 +289,44 @@ class StrTest(unittest.TestCase): replacement = 'a' s = ' ' * size s = s.replace(' ', replacement) - self.assertEquals(len(s), size) - self.assertEquals(s.count(replacement), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count(replacement), size) s = s.replace(replacement, ' ', size - 4) - self.assertEquals(len(s), size) - self.assertEquals(s.count(replacement), 4) - self.assertEquals(s[-10:], ' aaaa') + self.assertEqual(len(s), size) + self.assertEqual(s.count(replacement), 4) + self.assertEqual(s[-10:], ' aaaa') @bigmemtest(minsize=_2G, memuse=2) def test_rfind(self, size): SUBSTR = ' abc def ghi' sublen = len(SUBSTR) s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEquals(s.rfind(' '), sublen + size + SUBSTR.rfind(' ')) - self.assertEquals(s.rfind(SUBSTR), sublen + size) - self.assertEquals(s.rfind(' ', 0, size), SUBSTR.rfind(' ')) - self.assertEquals(s.rfind(SUBSTR, 0, sublen + size), 0) - self.assertEquals(s.rfind('i'), sublen + size + SUBSTR.rfind('i')) - self.assertEquals(s.rfind('i', 0, sublen), SUBSTR.rfind('i')) - self.assertEquals(s.rfind('i', 0, sublen + size), - SUBSTR.rfind('i')) - self.assertEquals(s.rfind('j'), -1) + self.assertEqual(s.rfind(' '), sublen + size + SUBSTR.rfind(' ')) + self.assertEqual(s.rfind(SUBSTR), sublen + size) + self.assertEqual(s.rfind(' ', 0, size), SUBSTR.rfind(' ')) + self.assertEqual(s.rfind(SUBSTR, 0, sublen + size), 0) + self.assertEqual(s.rfind('i'), sublen + size + SUBSTR.rfind('i')) + self.assertEqual(s.rfind('i', 0, sublen), SUBSTR.rfind('i')) + self.assertEqual(s.rfind('i', 0, sublen + size), + SUBSTR.rfind('i')) + self.assertEqual(s.rfind('j'), -1) @bigmemtest(minsize=_2G, memuse=2) def test_rindex(self, size): SUBSTR = ' abc def ghi' sublen = len(SUBSTR) s = ''.join([SUBSTR, '-' * size, SUBSTR]) - self.assertEquals(s.rindex(' '), + self.assertEqual(s.rindex(' '), sublen + size + SUBSTR.rindex(' ')) - self.assertEquals(s.rindex(SUBSTR), sublen + size) - self.assertEquals(s.rindex(' ', 0, sublen + size - 1), - SUBSTR.rindex(' ')) - self.assertEquals(s.rindex(SUBSTR, 0, sublen + size), 0) - self.assertEquals(s.rindex('i'), - sublen + size + SUBSTR.rindex('i')) - self.assertEquals(s.rindex('i', 0, sublen), SUBSTR.rindex('i')) - self.assertEquals(s.rindex('i', 0, sublen + size), - SUBSTR.rindex('i')) + self.assertEqual(s.rindex(SUBSTR), sublen + size) + self.assertEqual(s.rindex(' ', 0, sublen + size - 1), + SUBSTR.rindex(' ')) + self.assertEqual(s.rindex(SUBSTR, 0, sublen + size), 0) + self.assertEqual(s.rindex('i'), + sublen + size + SUBSTR.rindex('i')) + self.assertEqual(s.rindex('i', 0, sublen), SUBSTR.rindex('i')) + self.assertEqual(s.rindex('i', 0, sublen + size), + SUBSTR.rindex('i')) self.assertRaises(ValueError, s.rindex, 'j') @bigmemtest(minsize=_2G + 10, memuse=1) @@ -334,18 +334,18 @@ class StrTest(unittest.TestCase): SUBSTR = ' abc def ghi' s = SUBSTR.ljust(size) self.assertTrue(s.startswith(SUBSTR + ' ')) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G + 10, memuse=1) def test_rstrip(self, size): SUBSTR = ' abc def ghi' s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.rstrip(), SUBSTR.rstrip()) + self.assertEqual(len(s), size) + self.assertEqual(s.rstrip(), SUBSTR.rstrip()) del s s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) stripped = s.rstrip() self.assertTrue(stripped is s) @@ -360,12 +360,12 @@ class StrTest(unittest.TestCase): SUBSTR = 'a' + ' ' * chunksize s = SUBSTR * chunksize l = s.split() - self.assertEquals(len(l), chunksize) - self.assertEquals(set(l), set(['a'])) + self.assertEqual(len(l), chunksize) + self.assertEqual(set(l), set(['a'])) del l l = s.split('a') - self.assertEquals(len(l), chunksize + 1) - self.assertEquals(set(l), set(['', ' ' * chunksize])) + self.assertEqual(len(l), chunksize + 1) + self.assertEqual(set(l), set(['', ' ' * chunksize])) # Allocates a string of twice size (and briefly two) and a list of # size. Because of internal affairs, the s.split() call produces a @@ -377,12 +377,12 @@ class StrTest(unittest.TestCase): def test_split_large(self, size): s = ' a' * size + ' ' l = s.split() - self.assertEquals(len(l), size) - self.assertEquals(set(l), set(['a'])) + self.assertEqual(len(l), size) + self.assertEqual(set(l), set(['a'])) del l l = s.split('a') - self.assertEquals(len(l), size + 1) - self.assertEquals(set(l), set([' '])) + self.assertEqual(len(l), size + 1) + self.assertEqual(set(l), set([' '])) @bigmemtest(minsize=_2G, memuse=2.1) def test_splitlines(self, size): @@ -392,8 +392,8 @@ class StrTest(unittest.TestCase): SUBSTR = ' ' * chunksize + '\n' + ' ' * chunksize + '\r\n' s = SUBSTR * chunksize l = s.splitlines() - self.assertEquals(len(l), chunksize * 2) - self.assertEquals(set(l), set([' ' * chunksize])) + self.assertEqual(len(l), chunksize * 2) + self.assertEqual(set(l), set([' ' * chunksize])) @bigmemtest(minsize=_2G, memuse=2) def test_startswith(self, size): @@ -407,12 +407,12 @@ class StrTest(unittest.TestCase): def test_strip(self, size): SUBSTR = ' abc def ghi ' s = SUBSTR.rjust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) del s s = SUBSTR.ljust(size) - self.assertEquals(len(s), size) - self.assertEquals(s.strip(), SUBSTR.strip()) + self.assertEqual(len(s), size) + self.assertEqual(s.strip(), SUBSTR.strip()) @bigmemtest(minsize=_2G, memuse=2) def test_swapcase(self, size): @@ -421,9 +421,9 @@ class StrTest(unittest.TestCase): repeats = size // sublen + 2 s = SUBSTR * repeats s = s.swapcase() - self.assertEquals(len(s), sublen * repeats) - self.assertEquals(s[:sublen * 3], SUBSTR.swapcase() * 3) - self.assertEquals(s[-sublen * 3:], SUBSTR.swapcase() * 3) + self.assertEqual(len(s), sublen * repeats) + self.assertEqual(s[:sublen * 3], SUBSTR.swapcase() * 3) + self.assertEqual(s[-sublen * 3:], SUBSTR.swapcase() * 3) @bigmemtest(minsize=_2G, memuse=2) def test_title(self, size): @@ -441,19 +441,19 @@ class StrTest(unittest.TestCase): repeats = size // sublen + 2 s = SUBSTR * repeats s = s.translate(trans) - self.assertEquals(len(s), repeats * sublen) - self.assertEquals(s[:sublen], SUBSTR.translate(trans)) - self.assertEquals(s[-sublen:], SUBSTR.translate(trans)) - self.assertEquals(s.count('.'), 0) - self.assertEquals(s.count('!'), repeats * 2) - self.assertEquals(s.count('z'), repeats * 3) + self.assertEqual(len(s), repeats * sublen) + self.assertEqual(s[:sublen], SUBSTR.translate(trans)) + self.assertEqual(s[-sublen:], SUBSTR.translate(trans)) + self.assertEqual(s.count('.'), 0) + self.assertEqual(s.count('!'), repeats * 2) + self.assertEqual(s.count('z'), repeats * 3) @bigmemtest(minsize=_2G + 5, memuse=2) def test_upper(self, size): s = 'a' * size s = s.upper() - self.assertEquals(len(s), size) - self.assertEquals(s.count('A'), size) + self.assertEqual(len(s), size) + self.assertEqual(s.count('A'), size) @bigmemtest(minsize=_2G + 20, memuse=1) def test_zfill(self, size): @@ -461,8 +461,8 @@ class StrTest(unittest.TestCase): s = SUBSTR.zfill(size) self.assertTrue(s.endswith('0' + SUBSTR[1:])) self.assertTrue(s.startswith('-0')) - self.assertEquals(len(s), size) - self.assertEquals(s.count('0'), size - len(SUBSTR)) + self.assertEqual(len(s), size) + self.assertEqual(s.count('0'), size - len(SUBSTR)) @bigmemtest(minsize=_2G + 10, memuse=2) def test_format(self, size): @@ -471,7 +471,7 @@ class StrTest(unittest.TestCase): self.assertTrue(s == sf) del sf sf = '..%s..' % (s,) - self.assertEquals(len(sf), len(s) + 4) + self.assertEqual(len(sf), len(s) + 4) self.assertTrue(sf.startswith('..-')) self.assertTrue(sf.endswith('-..')) del s, sf @@ -481,18 +481,18 @@ class StrTest(unittest.TestCase): s = ''.join([edge, '%s', edge]) del edge s = s % '...' - self.assertEquals(len(s), size * 2 + 3) - self.assertEquals(s.count('.'), 3) - self.assertEquals(s.count('-'), size * 2) + self.assertEqual(len(s), size * 2 + 3) + self.assertEqual(s.count('.'), 3) + self.assertEqual(s.count('-'), size * 2) @bigmemtest(minsize=_2G + 10, memuse=2) def test_repr_small(self, size): s = '-' * size s = repr(s) - self.assertEquals(len(s), size + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('-'), size) + self.assertEqual(len(s), size + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('-'), size) del s # repr() will create a string four times as large as this 'binary # string', but we don't want to allocate much more than twice @@ -500,21 +500,21 @@ class StrTest(unittest.TestCase): size = size // 5 * 2 s = '\x00' * size s = repr(s) - self.assertEquals(len(s), size * 4 + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('\\'), size) - self.assertEquals(s.count('0'), size * 2) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) @bigmemtest(minsize=_2G + 10, memuse=5) def test_repr_large(self, size): s = '\x00' * size s = repr(s) - self.assertEquals(len(s), size * 4 + 2) - self.assertEquals(s[0], "'") - self.assertEquals(s[-1], "'") - self.assertEquals(s.count('\\'), size) - self.assertEquals(s.count('0'), size * 2) + self.assertEqual(len(s), size * 4 + 2) + self.assertEqual(s[0], "'") + self.assertEqual(s[-1], "'") + self.assertEqual(s.count('\\'), size) + self.assertEqual(s.count('0'), size * 2) @bigmemtest(minsize=2**32 // 5, memuse=6+2) def test_unicode_repr(self, size): @@ -526,20 +526,20 @@ class StrTest(unittest.TestCase): @bigmemtest(minsize=_1G + 2, memuse=3) def test_concat(self, size): s = '.' * size - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) s = s + s - self.assertEquals(len(s), size * 2) - self.assertEquals(s.count('.'), size * 2) + self.assertEqual(len(s), size * 2) + self.assertEqual(s.count('.'), size * 2) # This test is meaningful even with size < 2G, as long as the # repeated string is > 2G (but it tests more if both are > 2G :) @bigmemtest(minsize=_1G + 2, memuse=3) def test_repeat(self, size): s = '.' * size - self.assertEquals(len(s), size) + self.assertEqual(len(s), size) s = s * 2 - self.assertEquals(len(s), size * 2) - self.assertEquals(s.count('.'), size * 2) + self.assertEqual(len(s), size * 2) + self.assertEqual(s.count('.'), size * 2) @bigmemtest(minsize=_2G + 20, memuse=1) def test_slice_and_getitem(self, size): @@ -549,26 +549,26 @@ class StrTest(unittest.TestCase): stepsize = len(s) // 100 stepsize = stepsize - (stepsize % sublen) for i in range(0, len(s) - stepsize, stepsize): - self.assertEquals(s[i], SUBSTR[0]) - self.assertEquals(s[i:i + sublen], SUBSTR) - self.assertEquals(s[i:i + sublen:2], SUBSTR[::2]) + self.assertEqual(s[i], SUBSTR[0]) + self.assertEqual(s[i:i + sublen], SUBSTR) + self.assertEqual(s[i:i + sublen:2], SUBSTR[::2]) if i > 0: - self.assertEquals(s[i + sublen - 1:i - 1:-3], - SUBSTR[sublen::-3]) + self.assertEqual(s[i + sublen - 1:i - 1:-3], + SUBSTR[sublen::-3]) # Make sure we do some slicing and indexing near the end of the # string, too. - self.assertEquals(s[len(s) - 1], SUBSTR[-1]) - self.assertEquals(s[-1], SUBSTR[-1]) - self.assertEquals(s[len(s) - 10], SUBSTR[0]) - self.assertEquals(s[-sublen], SUBSTR[0]) - self.assertEquals(s[len(s):], '') - self.assertEquals(s[len(s) - 1:], SUBSTR[-1]) - self.assertEquals(s[-1:], SUBSTR[-1]) - self.assertEquals(s[len(s) - sublen:], SUBSTR) - self.assertEquals(s[-sublen:], SUBSTR) - self.assertEquals(len(s[:]), len(s)) - self.assertEquals(len(s[:len(s) - 5]), len(s) - 5) - self.assertEquals(len(s[5:-5]), len(s) - 10) + self.assertEqual(s[len(s) - 1], SUBSTR[-1]) + self.assertEqual(s[-1], SUBSTR[-1]) + self.assertEqual(s[len(s) - 10], SUBSTR[0]) + self.assertEqual(s[-sublen], SUBSTR[0]) + self.assertEqual(s[len(s):], '') + self.assertEqual(s[len(s) - 1:], SUBSTR[-1]) + self.assertEqual(s[-1:], SUBSTR[-1]) + self.assertEqual(s[len(s) - sublen:], SUBSTR) + self.assertEqual(s[-sublen:], SUBSTR) + self.assertEqual(len(s[:]), len(s)) + self.assertEqual(len(s[:len(s) - 5]), len(s) - 5) + self.assertEqual(len(s[5:-5]), len(s) - 10) self.assertRaises(IndexError, operator.getitem, s, len(s)) self.assertRaises(IndexError, operator.getitem, s, len(s) + 1) @@ -643,9 +643,9 @@ class TupleTest(unittest.TestCase): # skipped, in verbose mode.) def basic_concat_test(self, size): t = ((),) * size - self.assertEquals(len(t), size) + self.assertEqual(len(t), size) t = t + t - self.assertEquals(len(t), size * 2) + self.assertEqual(len(t), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_concat_small(self, size): @@ -658,7 +658,7 @@ class TupleTest(unittest.TestCase): @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5) def test_contains(self, size): t = (1, 2, 3, 4, 5) * size - self.assertEquals(len(t), size * 5) + self.assertEqual(len(t), size * 5) self.assertIn(5, t) self.assertNotIn((1, 2, 3, 4, 5), t) self.assertNotIn(0, t) @@ -674,27 +674,27 @@ class TupleTest(unittest.TestCase): @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): t = (None,) * size - self.assertEquals(len(t), size) - self.assertEquals(t[-1], None) - self.assertEquals(t[5], None) - self.assertEquals(t[size - 1], None) + self.assertEqual(len(t), size) + self.assertEqual(t[-1], None) + self.assertEqual(t[5], None) + self.assertEqual(t[size - 1], None) self.assertRaises(IndexError, operator.getitem, t, size) - self.assertEquals(t[:5], (None,) * 5) - self.assertEquals(t[-5:], (None,) * 5) - self.assertEquals(t[20:25], (None,) * 5) - self.assertEquals(t[-25:-20], (None,) * 5) - self.assertEquals(t[size - 5:], (None,) * 5) - self.assertEquals(t[size - 5:size], (None,) * 5) - self.assertEquals(t[size - 6:size - 2], (None,) * 4) - self.assertEquals(t[size:size], ()) - self.assertEquals(t[size:size+5], ()) + self.assertEqual(t[:5], (None,) * 5) + self.assertEqual(t[-5:], (None,) * 5) + self.assertEqual(t[20:25], (None,) * 5) + self.assertEqual(t[-25:-20], (None,) * 5) + self.assertEqual(t[size - 5:], (None,) * 5) + self.assertEqual(t[size - 5:size], (None,) * 5) + self.assertEqual(t[size - 6:size - 2], (None,) * 4) + self.assertEqual(t[size:size], ()) + self.assertEqual(t[size:size+5], ()) # Like test_concat, split in two. def basic_test_repeat(self, size): t = ('',) * size - self.assertEquals(len(t), size) + self.assertEqual(len(t), size) t = t * 2 - self.assertEquals(len(t), size * 2) + self.assertEqual(len(t), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_repeat_small(self, size): @@ -717,9 +717,9 @@ class TupleTest(unittest.TestCase): else: count = 0 for item in t: - self.assertEquals(item, count) + self.assertEqual(item, count) count += 1 - self.assertEquals(count, size) + self.assertEqual(count, size) @precisionbigmemtest(size=_1G - 25, memuse=9) def test_from_almost_2G_generator(self, size): @@ -727,9 +727,9 @@ class TupleTest(unittest.TestCase): t = tuple(xrange(size)) count = 0 for item in t: - self.assertEquals(item, count) + self.assertEqual(item, count) count += 1 - self.assertEquals(count, size) + self.assertEqual(count, size) except MemoryError: pass # acceptable, expected on 32-bit @@ -738,10 +738,10 @@ class TupleTest(unittest.TestCase): t = (0,) * size s = repr(t) # The repr of a tuple of 0's is exactly three times the tuple length. - self.assertEquals(len(s), size * 3) - self.assertEquals(s[:5], '(0, 0') - self.assertEquals(s[-5:], '0, 0)') - self.assertEquals(s.count('0'), size) + self.assertEqual(len(s), size * 3) + self.assertEqual(s[:5], '(0, 0') + self.assertEqual(s[-5:], '0, 0)') + self.assertEqual(s.count('0'), size) @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3) def test_repr_small(self, size): @@ -777,9 +777,9 @@ class ListTest(unittest.TestCase): # skipped, in verbose mode.) def basic_test_concat(self, size): l = [[]] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l = l + l - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_concat_small(self, size): @@ -792,7 +792,7 @@ class ListTest(unittest.TestCase): def basic_test_inplace_concat(self, size): l = [sys.stdout] * size l += l - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) @@ -807,7 +807,7 @@ class ListTest(unittest.TestCase): @bigmemtest(minsize=_2G // 5 + 10, memuse=8 * 5) def test_contains(self, size): l = [1, 2, 3, 4, 5] * size - self.assertEquals(len(l), size * 5) + self.assertEqual(len(l), size * 5) self.assertIn(5, l) self.assertNotIn([1, 2, 3, 4, 5], l) self.assertNotIn(0, l) @@ -820,66 +820,66 @@ class ListTest(unittest.TestCase): @bigmemtest(minsize=_2G + 10, memuse=8) def test_index_and_slice(self, size): l = [None] * size - self.assertEquals(len(l), size) - self.assertEquals(l[-1], None) - self.assertEquals(l[5], None) - self.assertEquals(l[size - 1], None) + self.assertEqual(len(l), size) + self.assertEqual(l[-1], None) + self.assertEqual(l[5], None) + self.assertEqual(l[size - 1], None) self.assertRaises(IndexError, operator.getitem, l, size) - self.assertEquals(l[:5], [None] * 5) - self.assertEquals(l[-5:], [None] * 5) - self.assertEquals(l[20:25], [None] * 5) - self.assertEquals(l[-25:-20], [None] * 5) - self.assertEquals(l[size - 5:], [None] * 5) - self.assertEquals(l[size - 5:size], [None] * 5) - self.assertEquals(l[size - 6:size - 2], [None] * 4) - self.assertEquals(l[size:size], []) - self.assertEquals(l[size:size+5], []) + self.assertEqual(l[:5], [None] * 5) + self.assertEqual(l[-5:], [None] * 5) + self.assertEqual(l[20:25], [None] * 5) + self.assertEqual(l[-25:-20], [None] * 5) + self.assertEqual(l[size - 5:], [None] * 5) + self.assertEqual(l[size - 5:size], [None] * 5) + self.assertEqual(l[size - 6:size - 2], [None] * 4) + self.assertEqual(l[size:size], []) + self.assertEqual(l[size:size+5], []) l[size - 2] = 5 - self.assertEquals(len(l), size) - self.assertEquals(l[-3:], [None, 5, None]) - self.assertEquals(l.count(5), 1) + self.assertEqual(len(l), size) + self.assertEqual(l[-3:], [None, 5, None]) + self.assertEqual(l.count(5), 1) self.assertRaises(IndexError, operator.setitem, l, size, 6) - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l[size - 7:] = [1, 2, 3, 4, 5] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[-7:], [None, None, 1, 2, 3, 4, 5]) + self.assertEqual(len(l), size) + self.assertEqual(l[-7:], [None, None, 1, 2, 3, 4, 5]) l[:7] = [1, 2, 3, 4, 5] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[:7], [1, 2, 3, 4, 5, None, None]) + self.assertEqual(len(l), size) + self.assertEqual(l[:7], [1, 2, 3, 4, 5, None, None]) del l[size - 1] size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-1], 4) + self.assertEqual(len(l), size) + self.assertEqual(l[-1], 4) del l[-2:] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[-1], 2) + self.assertEqual(len(l), size) + self.assertEqual(l[-1], 2) del l[0] size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[0], 2) + self.assertEqual(len(l), size) + self.assertEqual(l[0], 2) del l[:2] size -= 2 - self.assertEquals(len(l), size) - self.assertEquals(l[0], 4) + self.assertEqual(len(l), size) + self.assertEqual(l[0], 4) # Like test_concat, split in two. def basic_test_repeat(self, size): l = [] * size self.assertFalse(l) l = [''] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l = l * 2 - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) @bigmemtest(minsize=_2G // 2 + 2, memuse=24) def test_repeat_small(self, size): @@ -892,13 +892,13 @@ class ListTest(unittest.TestCase): def basic_test_inplace_repeat(self, size): l = [''] l *= size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) self.assertTrue(l[0] is l[-1]) del l l = [''] * size l *= 2 - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[size - 1] is l[-1]) @bigmemtest(minsize=_2G // 2 + 2, memuse=16) @@ -913,10 +913,10 @@ class ListTest(unittest.TestCase): l = [0] * size s = repr(l) # The repr of a list of 0's is exactly three times the list length. - self.assertEquals(len(s), size * 3) - self.assertEquals(s[:5], '[0, 0') - self.assertEquals(s[-5:], '0, 0]') - self.assertEquals(s.count('0'), size) + self.assertEqual(len(s), size * 3) + self.assertEqual(s[:5], '[0, 0') + self.assertEqual(s[-5:], '0, 0]') + self.assertEqual(s.count('0'), size) @bigmemtest(minsize=_2G // 3 + 2, memuse=8 + 3) def test_repr_small(self, size): @@ -932,20 +932,20 @@ class ListTest(unittest.TestCase): def test_append(self, size): l = [object()] * size l.append(object()) - self.assertEquals(len(l), size+1) + self.assertEqual(len(l), size+1) self.assertTrue(l[-3] is l[-2]) self.assertFalse(l[-2] is l[-1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_count(self, size): l = [1, 2, 3, 4, 5] * size - self.assertEquals(l.count(1), size) - self.assertEquals(l.count("1"), 0) + self.assertEqual(l.count(1), size) + self.assertEqual(l.count("1"), 0) def basic_test_extend(self, size): l = [file] * size l.extend(l) - self.assertEquals(len(l), size * 2) + self.assertEqual(len(l), size * 2) self.assertTrue(l[0] is l[-1]) self.assertTrue(l[size - 1] is l[size + 1]) @@ -961,9 +961,9 @@ class ListTest(unittest.TestCase): def test_index(self, size): l = [1L, 2L, 3L, 4L, 5L] * size size *= 5 - self.assertEquals(l.index(1), 0) - self.assertEquals(l.index(5, size - 5), size - 1) - self.assertEquals(l.index(5, size - 5, size), size - 1) + self.assertEqual(l.index(1), 0) + self.assertEqual(l.index(5, size - 5), size - 1) + self.assertEqual(l.index(5, size - 5, size), size - 1) self.assertRaises(ValueError, l.index, 1, size - 4, size) self.assertRaises(ValueError, l.index, 6L) @@ -973,80 +973,80 @@ class ListTest(unittest.TestCase): l = [1.0] * size l.insert(size - 1, "A") size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-3:], [1.0, "A", 1.0]) + self.assertEqual(len(l), size) + self.assertEqual(l[-3:], [1.0, "A", 1.0]) l.insert(size + 1, "B") size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-3:], ["A", 1.0, "B"]) + self.assertEqual(len(l), size) + self.assertEqual(l[-3:], ["A", 1.0, "B"]) l.insert(1, "C") size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[:3], [1.0, "C", 1.0]) - self.assertEquals(l[size - 3:], ["A", 1.0, "B"]) + self.assertEqual(len(l), size) + self.assertEqual(l[:3], [1.0, "C", 1.0]) + self.assertEqual(l[size - 3:], ["A", 1.0, "B"]) @bigmemtest(minsize=_2G // 5 + 4, memuse=8 * 5) def test_pop(self, size): l = [u"a", u"b", u"c", u"d", u"e"] * size size *= 5 - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) item = l.pop() size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, u"e") - self.assertEquals(l[-2:], [u"c", u"d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, u"e") + self.assertEqual(l[-2:], [u"c", u"d"]) item = l.pop(0) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, u"a") - self.assertEquals(l[:2], [u"b", u"c"]) + self.assertEqual(len(l), size) + self.assertEqual(item, u"a") + self.assertEqual(l[:2], [u"b", u"c"]) item = l.pop(size - 2) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(item, u"c") - self.assertEquals(l[-2:], [u"b", u"d"]) + self.assertEqual(len(l), size) + self.assertEqual(item, u"c") + self.assertEqual(l[-2:], [u"b", u"d"]) @bigmemtest(minsize=_2G + 10, memuse=8) def test_remove(self, size): l = [10] * size - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) l.remove(10) size -= 1 - self.assertEquals(len(l), size) + self.assertEqual(len(l), size) # Because of the earlier l.remove(), this append doesn't trigger # a resize. l.append(5) size += 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-2:], [10, 5]) + self.assertEqual(len(l), size) + self.assertEqual(l[-2:], [10, 5]) l.remove(5) size -= 1 - self.assertEquals(len(l), size) - self.assertEquals(l[-2:], [10, 10]) + self.assertEqual(len(l), size) + self.assertEqual(l[-2:], [10, 10]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_reverse(self, size): l = [1, 2, 3, 4, 5] * size l.reverse() - self.assertEquals(len(l), size * 5) - self.assertEquals(l[-5:], [5, 4, 3, 2, 1]) - self.assertEquals(l[:5], [5, 4, 3, 2, 1]) + self.assertEqual(len(l), size * 5) + self.assertEqual(l[-5:], [5, 4, 3, 2, 1]) + self.assertEqual(l[:5], [5, 4, 3, 2, 1]) @bigmemtest(minsize=_2G // 5 + 2, memuse=8 * 5) def test_sort(self, size): l = [1, 2, 3, 4, 5] * size l.sort() - self.assertEquals(len(l), size * 5) - self.assertEquals(l.count(1), size) - self.assertEquals(l[:10], [1] * 10) - self.assertEquals(l[-10:], [5] * 10) + self.assertEqual(len(l), size * 5) + self.assertEqual(l.count(1), size) + self.assertEqual(l[:10], [1] * 10) + self.assertEqual(l[-10:], [5] * 10) class BufferTest(unittest.TestCase): @@ -1060,9 +1060,9 @@ class BufferTest(unittest.TestCase): else: count = 0 for c in b: - self.assertEquals(c, 'A') + self.assertEqual(c, 'A') count += 1 - self.assertEquals(count, size*4) + self.assertEqual(count, size*4) def test_main(): test_support.run_unittest(StrTest, TupleTest, ListTest, BufferTest) diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py index 69b6ae4..d8fb2d5 100644 --- a/Lib/test/test_builtin.py +++ b/Lib/test/test_builtin.py @@ -651,15 +651,15 @@ class BuiltinTest(unittest.TestCase): class X: def __hash__(self): return 2**100 - self.assertEquals(type(hash(X())), int) + self.assertEqual(type(hash(X())), int) class Y(object): def __hash__(self): return 2**100 - self.assertEquals(type(hash(Y())), int) + self.assertEqual(type(hash(Y())), int) class Z(long): def __hash__(self): return self - self.assertEquals(hash(Z(42)), hash(42L)) + self.assertEqual(hash(Z(42)), hash(42L)) def test_hex(self): self.assertEqual(hex(16), '0x10') @@ -930,7 +930,7 @@ class BuiltinTest(unittest.TestCase): self.assertEqual(next(it), 1) self.assertRaises(StopIteration, next, it) self.assertRaises(StopIteration, next, it) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) class Iter(object): def __iter__(self): @@ -939,7 +939,7 @@ class BuiltinTest(unittest.TestCase): raise StopIteration it = iter(Iter()) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) self.assertRaises(StopIteration, next, it) def gen(): @@ -947,9 +947,9 @@ class BuiltinTest(unittest.TestCase): return it = gen() - self.assertEquals(next(it), 1) + self.assertEqual(next(it), 1) self.assertRaises(StopIteration, next, it) - self.assertEquals(next(it, 42), 42) + self.assertEqual(next(it, 42), 42) def test_oct(self): self.assertEqual(oct(100), '0144') diff --git a/Lib/test/test_bytes.py b/Lib/test/test_bytes.py index d0f5662..6b5ef36 100644 --- a/Lib/test/test_bytes.py +++ b/Lib/test/test_bytes.py @@ -255,11 +255,11 @@ class BaseBytesTest(unittest.TestCase): def test_fromhex(self): self.assertRaises(TypeError, self.type2test.fromhex) self.assertRaises(TypeError, self.type2test.fromhex, 1) - self.assertEquals(self.type2test.fromhex(u''), self.type2test()) + self.assertEqual(self.type2test.fromhex(u''), self.type2test()) b = bytearray([0x1a, 0x2b, 0x30]) - self.assertEquals(self.type2test.fromhex(u'1a2B30'), b) - self.assertEquals(self.type2test.fromhex(u' 1A 2B 30 '), b) - self.assertEquals(self.type2test.fromhex(u'0000'), b'\0\0') + self.assertEqual(self.type2test.fromhex(u'1a2B30'), b) + self.assertEqual(self.type2test.fromhex(u' 1A 2B 30 '), b) + self.assertEqual(self.type2test.fromhex(u'0000'), b'\0\0') self.assertRaises(ValueError, self.type2test.fromhex, u'a') self.assertRaises(ValueError, self.type2test.fromhex, u'rt') self.assertRaises(ValueError, self.type2test.fromhex, u'1a b cd') @@ -587,11 +587,11 @@ class ByteArrayTest(BaseBytesTest): data.reverse() L[start:stop:step] = data b[start:stop:step] = data - self.assertEquals(b, bytearray(L)) + self.assertEqual(b, bytearray(L)) del L[start:stop:step] del b[start:stop:step] - self.assertEquals(b, bytearray(L)) + self.assertEqual(b, bytearray(L)) def test_setslice_trap(self): # This test verifies that we correctly handle assigning self @@ -771,25 +771,25 @@ class ByteArrayTest(BaseBytesTest): resize(10) orig = b[:] self.assertRaises(BufferError, resize, 11) - self.assertEquals(b, orig) + self.assertEqual(b, orig) self.assertRaises(BufferError, resize, 9) - self.assertEquals(b, orig) + self.assertEqual(b, orig) self.assertRaises(BufferError, resize, 0) - self.assertEquals(b, orig) + self.assertEqual(b, orig) # Other operations implying resize self.assertRaises(BufferError, b.pop, 0) - self.assertEquals(b, orig) + self.assertEqual(b, orig) self.assertRaises(BufferError, b.remove, b[1]) - self.assertEquals(b, orig) + self.assertEqual(b, orig) def delitem(): del b[1] self.assertRaises(BufferError, delitem) - self.assertEquals(b, orig) + self.assertEqual(b, orig) # deleting a non-contiguous slice def delslice(): b[1:-1:2] = b"" self.assertRaises(BufferError, delslice) - self.assertEquals(b, orig) + self.assertEqual(b, orig) def test_empty_bytearray(self): # Issue #7561: operations on empty bytearrays could crash in many diff --git a/Lib/test/test_cfgparser.py b/Lib/test/test_cfgparser.py index 20c10dc..d44a415 100644 --- a/Lib/test/test_cfgparser.py +++ b/Lib/test/test_cfgparser.py @@ -572,14 +572,14 @@ class SortedTestCase(RawConfigParserTestCase): "k=v\n") output = StringIO.StringIO() self.cf.write(output) - self.assertEquals(output.getvalue(), - "[a]\n" - "k = v\n\n" - "[b]\n" - "o1 = 4\n" - "o2 = 3\n" - "o3 = 2\n" - "o4 = 1\n\n") + self.assertEqual(output.getvalue(), + "[a]\n" + "k = v\n\n" + "[b]\n" + "o1 = 4\n" + "o2 = 3\n" + "o3 = 2\n" + "o4 = 1\n\n") def test_main(): diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py index 554bf06..e282a51 100644 --- a/Lib/test/test_cgi.py +++ b/Lib/test/test_cgi.py @@ -251,7 +251,7 @@ Content-Disposition: form-data; name="submit" -----------------------------721837373350705526688164684-- """ fs = cgi.FieldStorage(fp=StringIO(postdata), environ=env) - self.assertEquals(len(fs.list), 4) + self.assertEqual(len(fs.list), 4) expect = [{'name':'id', 'filename':None, 'value':'1234'}, {'name':'title', 'filename':None, 'value':''}, {'name':'file', 'filename':'test.txt','value':'Testing 123.\n'}, @@ -259,7 +259,7 @@ Content-Disposition: form-data; name="submit" for x in range(len(fs.list)): for k, exp in expect[x].items(): got = getattr(fs.list[x], k) - self.assertEquals(got, exp) + self.assertEqual(got, exp) _qs_result = { 'key1': 'value1', diff --git a/Lib/test/test_charmapcodec.py b/Lib/test/test_charmapcodec.py index 2866984..d984059 100644 --- a/Lib/test/test_charmapcodec.py +++ b/Lib/test/test_charmapcodec.py @@ -27,24 +27,24 @@ codecname = 'testcodec' class CharmapCodecTest(unittest.TestCase): def test_constructorx(self): - self.assertEquals(unicode('abc', codecname), u'abc') - self.assertEquals(unicode('xdef', codecname), u'abcdef') - self.assertEquals(unicode('defx', codecname), u'defabc') - self.assertEquals(unicode('dxf', codecname), u'dabcf') - self.assertEquals(unicode('dxfx', codecname), u'dabcfabc') + self.assertEqual(unicode('abc', codecname), u'abc') + self.assertEqual(unicode('xdef', codecname), u'abcdef') + self.assertEqual(unicode('defx', codecname), u'defabc') + self.assertEqual(unicode('dxf', codecname), u'dabcf') + self.assertEqual(unicode('dxfx', codecname), u'dabcfabc') def test_encodex(self): - self.assertEquals(u'abc'.encode(codecname), 'abc') - self.assertEquals(u'xdef'.encode(codecname), 'abcdef') - self.assertEquals(u'defx'.encode(codecname), 'defabc') - self.assertEquals(u'dxf'.encode(codecname), 'dabcf') - self.assertEquals(u'dxfx'.encode(codecname), 'dabcfabc') + self.assertEqual(u'abc'.encode(codecname), 'abc') + self.assertEqual(u'xdef'.encode(codecname), 'abcdef') + self.assertEqual(u'defx'.encode(codecname), 'defabc') + self.assertEqual(u'dxf'.encode(codecname), 'dabcf') + self.assertEqual(u'dxfx'.encode(codecname), 'dabcfabc') def test_constructory(self): - self.assertEquals(unicode('ydef', codecname), u'def') - self.assertEquals(unicode('defy', codecname), u'def') - self.assertEquals(unicode('dyf', codecname), u'df') - self.assertEquals(unicode('dyfy', codecname), u'df') + self.assertEqual(unicode('ydef', codecname), u'def') + self.assertEqual(unicode('defy', codecname), u'def') + self.assertEqual(unicode('dyf', codecname), u'df') + self.assertEqual(unicode('dyfy', codecname), u'df') def test_maptoundefined(self): self.assertRaises(UnicodeError, unicode, 'abc\001', codecname) diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py index e7b7752..0f25101 100644 --- a/Lib/test/test_class.py +++ b/Lib/test/test_class.py @@ -475,7 +475,7 @@ class ClassTests(unittest.TestCase): del testme import gc gc.collect() - self.assertEquals(["crab people, crab people"], x) + self.assertEqual(["crab people, crab people"], x) def testBadTypeReturned(self): # return values of some method are type-checked @@ -507,14 +507,14 @@ class ClassTests(unittest.TestCase): callLst[:] = [] as_int = int(mixIntAndLong) - self.assertEquals(type(as_int), long) - self.assertEquals(as_int, 42L) + self.assertEqual(type(as_int), long) + self.assertEqual(as_int, 42L) self.assertCallStack([('__int__', (mixIntAndLong,))]) callLst[:] = [] as_long = long(mixIntAndLong) - self.assertEquals(type(as_long), long) - self.assertEquals(as_long, 64) + self.assertEqual(type(as_long), long) + self.assertEqual(as_long, 64) self.assertCallStack([('__long__', (mixIntAndLong,))]) def testHashStuff(self): @@ -599,17 +599,17 @@ class ClassTests(unittest.TestCase): a1 = A(1) a2 = A(2) - self.assertEquals(a1.f, a1.f) - self.assertNotEquals(a1.f, a2.f) - self.assertNotEquals(a1.f, a1.g) - self.assertEquals(a1.f, A(1).f) - self.assertEquals(hash(a1.f), hash(a1.f)) - self.assertEquals(hash(a1.f), hash(A(1).f)) - - self.assertNotEquals(A.f, a1.f) - self.assertNotEquals(A.f, A.g) - self.assertEquals(B.f, A.f) - self.assertEquals(hash(B.f), hash(A.f)) + self.assertEqual(a1.f, a1.f) + self.assertNotEqual(a1.f, a2.f) + self.assertNotEqual(a1.f, a1.g) + self.assertEqual(a1.f, A(1).f) + self.assertEqual(hash(a1.f), hash(a1.f)) + self.assertEqual(hash(a1.f), hash(A(1).f)) + + self.assertNotEqual(A.f, a1.f) + self.assertNotEqual(A.f, A.g) + self.assertEqual(B.f, A.f) + self.assertEqual(hash(B.f), hash(A.f)) # the following triggers a SystemError in 2.4 a = A(hash(A.f.im_func)^(-1)) diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py index e83a919..97adf59 100644 --- a/Lib/test/test_code.py +++ b/Lib/test/test_code.py @@ -106,9 +106,9 @@ class CodeTest(unittest.TestCase): def test_newempty(self): co = _testcapi.code_newempty("filename", "funcname", 15) - self.assertEquals(co.co_filename, "filename") - self.assertEquals(co.co_name, "funcname") - self.assertEquals(co.co_firstlineno, 15) + self.assertEqual(co.co_filename, "filename") + self.assertEqual(co.co_name, "funcname") + self.assertEqual(co.co_firstlineno, 15) class CodeWeakRefTest(unittest.TestCase): diff --git a/Lib/test/test_codeccallbacks.py b/Lib/test/test_codeccallbacks.py index 635a15f..4825f43 100644 --- a/Lib/test/test_codeccallbacks.py +++ b/Lib/test/test_codeccallbacks.py @@ -186,7 +186,7 @@ class CodecCallbackTest(unittest.TestCase): charmap = dict([ (ord(c), 2*c.upper()) for c in "abcdefgh"]) sin = u"abc" sout = "AABBCC" - self.assertEquals(codecs.charmap_encode(sin, "strict", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "strict", charmap)[0], sout) sin = u"abcA" self.assertRaises(UnicodeError, codecs.charmap_encode, sin, "strict", charmap) @@ -194,7 +194,7 @@ class CodecCallbackTest(unittest.TestCase): charmap[ord("?")] = "XYZ" sin = u"abcDEF" sout = "AABBCCXYZXYZXYZ" - self.assertEquals(codecs.charmap_encode(sin, "replace", charmap)[0], sout) + self.assertEqual(codecs.charmap_encode(sin, "replace", charmap)[0], sout) charmap[ord("?")] = u"XYZ" self.assertRaises(TypeError, codecs.charmap_encode, sin, "replace", charmap) @@ -327,7 +327,7 @@ class CodecCallbackTest(unittest.TestCase): # check with the correct number and type of arguments exc = exctype(*args) - self.assertEquals(str(exc), msg) + self.assertEqual(str(exc), msg) def test_unicodeencodeerror(self): self.check_exceptionobjectargs( @@ -437,15 +437,15 @@ class CodecCallbackTest(unittest.TestCase): UnicodeError("ouch") ) # If the correct exception is passed in, "ignore" returns an empty replacement - self.assertEquals( + self.assertEqual( codecs.ignore_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), (u"", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors(UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch")), (u"", 1) ) - self.assertEquals( + self.assertEqual( codecs.ignore_errors(UnicodeTranslateError(u"\u3042", 0, 1, "ouch")), (u"", 1) ) @@ -474,15 +474,15 @@ class CodecCallbackTest(unittest.TestCase): BadObjectUnicodeDecodeError() ) # With the correct exception, "replace" returns an "?" or u"\ufffd" replacement - self.assertEquals( + self.assertEqual( codecs.replace_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), (u"?", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors(UnicodeDecodeError("ascii", "\xff", 0, 1, "ouch")), (u"\ufffd", 1) ) - self.assertEquals( + self.assertEqual( codecs.replace_errors(UnicodeTranslateError(u"\u3042", 0, 1, "ouch")), (u"\ufffd", 1) ) @@ -514,7 +514,7 @@ class CodecCallbackTest(unittest.TestCase): # Use the correct exception cs = (0, 1, 9, 10, 99, 100, 999, 1000, 9999, 10000, 0x3042) s = "".join(unichr(c) for c in cs) - self.assertEquals( + self.assertEqual( codecs.xmlcharrefreplace_errors( UnicodeEncodeError("ascii", s, 0, len(s), "ouch") ), @@ -546,32 +546,32 @@ class CodecCallbackTest(unittest.TestCase): UnicodeTranslateError(u"\u3042", 0, 1, "ouch") ) # Use the correct exception - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\u3042", 0, 1, "ouch")), (u"\\u3042", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\x00", 0, 1, "ouch")), (u"\\x00", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\xff", 0, 1, "ouch")), (u"\\xff", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\u0100", 0, 1, "ouch")), (u"\\u0100", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\uffff", 0, 1, "ouch")), (u"\\uffff", 1) ) if sys.maxunicode>0xffff: - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\U00010000", 0, 1, "ouch")), (u"\\U00010000", 1) ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors(UnicodeEncodeError("ascii", u"\U0010ffff", 0, 1, "ouch")), (u"\\U0010ffff", 1) ) @@ -603,14 +603,14 @@ class CodecCallbackTest(unittest.TestCase): ) def test_lookup(self): - self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) - self.assertEquals(codecs.ignore_errors, codecs.lookup_error("ignore")) - self.assertEquals(codecs.strict_errors, codecs.lookup_error("strict")) - self.assertEquals( + self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict")) + self.assertEqual(codecs.ignore_errors, codecs.lookup_error("ignore")) + self.assertEqual(codecs.strict_errors, codecs.lookup_error("strict")) + self.assertEqual( codecs.xmlcharrefreplace_errors, codecs.lookup_error("xmlcharrefreplace") ) - self.assertEquals( + self.assertEqual( codecs.backslashreplace_errors, codecs.lookup_error("backslashreplace") ) @@ -686,11 +686,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"0") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"0") # Valid negative position handler.pos = -2 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"") # Negative position out of bounds handler.pos = -3 @@ -698,11 +698,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"0") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"0") # Largest valid positive position (one beyond end of input) handler.pos = 2 - self.assertEquals("\xff0".decode("ascii", "test.posreturn"), u"") + self.assertEqual("\xff0".decode("ascii", "test.posreturn"), u"") # Invalid positive position handler.pos = 3 @@ -710,7 +710,7 @@ class CodecCallbackTest(unittest.TestCase): # Restart at the "0" handler.pos = 6 - self.assertEquals("\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), u"0") + self.assertEqual("\\uyyyy0".decode("raw-unicode-escape", "test.posreturn"), u"0") class D(dict): def __getitem__(self, key): @@ -740,11 +740,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid negative position handler.pos = -1 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "0") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "0") # Valid negative position handler.pos = -2 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "") # Negative position out of bounds handler.pos = -3 @@ -752,11 +752,11 @@ class CodecCallbackTest(unittest.TestCase): # Valid positive position handler.pos = 1 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "0") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "0") # Largest valid positive position (one beyond end of input handler.pos = 2 - self.assertEquals(u"\xff0".encode("ascii", "test.posreturn"), "") + self.assertEqual(u"\xff0".encode("ascii", "test.posreturn"), "") # Invalid positive position handler.pos = 3 diff --git a/Lib/test/test_codecs.py b/Lib/test/test_codecs.py index 4c020c3..7cd7141 100644 --- a/Lib/test/test_codecs.py +++ b/Lib/test/test_codecs.py @@ -267,7 +267,7 @@ class UTF32Test(ReadTest): # try to read it back s = StringIO.StringIO(d) f = reader(s) - self.assertEquals(f.read(), u"spamspam") + self.assertEqual(f.read(), u"spamspam") def test_badbom(self): s = StringIO.StringIO(4*"\xff") @@ -425,7 +425,7 @@ class UTF16Test(ReadTest): # try to read it back s = StringIO.StringIO(d) f = reader(s) - self.assertEquals(f.read(), u"spamspam") + self.assertEqual(f.read(), u"spamspam") def test_badbom(self): s = StringIO.StringIO("\xff\xff") @@ -673,7 +673,7 @@ class UTF8SigTest(ReadTest): class EscapeDecodeTest(unittest.TestCase): def test_empty(self): - self.assertEquals(codecs.escape_decode(""), ("", 0)) + self.assertEqual(codecs.escape_decode(""), ("", 0)) class RecodingTest(unittest.TestCase): def test_recoding(self): @@ -800,11 +800,11 @@ class PunycodeTest(unittest.TestCase): # code produces only lower case. Converting just puny to # lower is also insufficient, since some of the input characters # are upper case. - self.assertEquals(uni.encode("punycode").lower(), puny.lower()) + self.assertEqual(uni.encode("punycode").lower(), puny.lower()) def test_decode(self): for uni, puny in punycode_testcases: - self.assertEquals(uni, puny.decode("punycode")) + self.assertEqual(uni, puny.decode("punycode")) class UnicodeInternalTest(unittest.TestCase): def test_bug1251300(self): @@ -826,7 +826,7 @@ class UnicodeInternalTest(unittest.TestCase): for internal, uni in ok: if sys.byteorder == "little": internal = "".join(reversed(internal)) - self.assertEquals(uni, internal.decode("unicode_internal")) + self.assertEqual(uni, internal.decode("unicode_internal")) for internal in not_ok: if sys.byteorder == "little": internal = "".join(reversed(internal)) @@ -838,10 +838,10 @@ class UnicodeInternalTest(unittest.TestCase): try: "\x00\x00\x00\x00\x00\x11\x11\x00".decode("unicode_internal") except UnicodeDecodeError, ex: - self.assertEquals("unicode_internal", ex.encoding) - self.assertEquals("\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) - self.assertEquals(4, ex.start) - self.assertEquals(8, ex.end) + self.assertEqual("unicode_internal", ex.encoding) + self.assertEqual("\x00\x00\x00\x00\x00\x11\x11\x00", ex.object) + self.assertEqual(4, ex.start) + self.assertEqual(8, ex.end) else: self.fail() @@ -852,16 +852,16 @@ class UnicodeInternalTest(unittest.TestCase): ab = u"ab".encode("unicode_internal") ignored = decoder("%s\x22\x22\x22\x22%s" % (ab[:4], ab[4:]), "UnicodeInternalTest") - self.assertEquals((u"ab", 12), ignored) + self.assertEqual((u"ab", 12), ignored) def test_encode_length(self): # Issue 3739 encoder = codecs.getencoder("unicode_internal") - self.assertEquals(encoder(u"a")[1], 1) - self.assertEquals(encoder(u"\xe9\u0142")[1], 2) + self.assertEqual(encoder(u"a")[1], 1) + self.assertEqual(encoder(u"\xe9\u0142")[1], 2) encoder = codecs.getencoder("string-escape") - self.assertEquals(encoder(r'\x00')[1], 4) + self.assertEqual(encoder(r'\x00')[1], 4) # From http://www.gnu.org/software/libidn/draft-josefsson-idn-test-vectors.html nameprep_tests = [ @@ -1032,102 +1032,102 @@ class NameprepTest(unittest.TestCase): else: prepped = unicode(prepped, "utf-8") try: - self.assertEquals(nameprep(orig), prepped) + self.assertEqual(nameprep(orig), prepped) except Exception,e: raise test_support.TestFailed("Test 3.%d: %s" % (pos+1, str(e))) class IDNACodecTest(unittest.TestCase): def test_builtin_decode(self): - self.assertEquals(unicode("python.org", "idna"), u"python.org") - self.assertEquals(unicode("python.org.", "idna"), u"python.org.") - self.assertEquals(unicode("xn--pythn-mua.org", "idna"), u"pyth\xf6n.org") - self.assertEquals(unicode("xn--pythn-mua.org.", "idna"), u"pyth\xf6n.org.") + self.assertEqual(unicode("python.org", "idna"), u"python.org") + self.assertEqual(unicode("python.org.", "idna"), u"python.org.") + self.assertEqual(unicode("xn--pythn-mua.org", "idna"), u"pyth\xf6n.org") + self.assertEqual(unicode("xn--pythn-mua.org.", "idna"), u"pyth\xf6n.org.") def test_builtin_encode(self): - self.assertEquals(u"python.org".encode("idna"), "python.org") - self.assertEquals("python.org.".encode("idna"), "python.org.") - self.assertEquals(u"pyth\xf6n.org".encode("idna"), "xn--pythn-mua.org") - self.assertEquals(u"pyth\xf6n.org.".encode("idna"), "xn--pythn-mua.org.") + self.assertEqual(u"python.org".encode("idna"), "python.org") + self.assertEqual("python.org.".encode("idna"), "python.org.") + self.assertEqual(u"pyth\xf6n.org".encode("idna"), "xn--pythn-mua.org") + self.assertEqual(u"pyth\xf6n.org.".encode("idna"), "xn--pythn-mua.org.") def test_stream(self): import StringIO r = codecs.getreader("idna")(StringIO.StringIO("abc")) r.read(3) - self.assertEquals(r.read(), u"") + self.assertEqual(r.read(), u"") def test_incremental_decode(self): - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("python.org", "idna")), u"python.org" ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("python.org.", "idna")), u"python.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("xn--pythn-mua.org.", "idna")), u"pyth\xf6n.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterdecode("xn--pythn-mua.org.", "idna")), u"pyth\xf6n.org." ) decoder = codecs.getincrementaldecoder("idna")() - self.assertEquals(decoder.decode("xn--xam", ), u"") - self.assertEquals(decoder.decode("ple-9ta.o", ), u"\xe4xample.") - self.assertEquals(decoder.decode(u"rg"), u"") - self.assertEquals(decoder.decode(u"", True), u"org") + self.assertEqual(decoder.decode("xn--xam", ), u"") + self.assertEqual(decoder.decode("ple-9ta.o", ), u"\xe4xample.") + self.assertEqual(decoder.decode(u"rg"), u"") + self.assertEqual(decoder.decode(u"", True), u"org") decoder.reset() - self.assertEquals(decoder.decode("xn--xam", ), u"") - self.assertEquals(decoder.decode("ple-9ta.o", ), u"\xe4xample.") - self.assertEquals(decoder.decode("rg."), u"org.") - self.assertEquals(decoder.decode("", True), u"") + self.assertEqual(decoder.decode("xn--xam", ), u"") + self.assertEqual(decoder.decode("ple-9ta.o", ), u"\xe4xample.") + self.assertEqual(decoder.decode("rg."), u"org.") + self.assertEqual(decoder.decode("", True), u"") def test_incremental_encode(self): - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"python.org", "idna")), "python.org" ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"python.org.", "idna")), "python.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"pyth\xf6n.org.", "idna")), "xn--pythn-mua.org." ) - self.assertEquals( + self.assertEqual( "".join(codecs.iterencode(u"pyth\xf6n.org.", "idna")), "xn--pythn-mua.org." ) encoder = codecs.getincrementalencoder("idna")() - self.assertEquals(encoder.encode(u"\xe4x"), "") - self.assertEquals(encoder.encode(u"ample.org"), "xn--xample-9ta.") - self.assertEquals(encoder.encode(u"", True), "org") + self.assertEqual(encoder.encode(u"\xe4x"), "") + self.assertEqual(encoder.encode(u"ample.org"), "xn--xample-9ta.") + self.assertEqual(encoder.encode(u"", True), "org") encoder.reset() - self.assertEquals(encoder.encode(u"\xe4x"), "") - self.assertEquals(encoder.encode(u"ample.org."), "xn--xample-9ta.org.") - self.assertEquals(encoder.encode(u"", True), "") + self.assertEqual(encoder.encode(u"\xe4x"), "") + self.assertEqual(encoder.encode(u"ample.org."), "xn--xample-9ta.org.") + self.assertEqual(encoder.encode(u"", True), "") class CodecsModuleTest(unittest.TestCase): def test_decode(self): - self.assertEquals(codecs.decode('\xe4\xf6\xfc', 'latin-1'), + self.assertEqual(codecs.decode('\xe4\xf6\xfc', 'latin-1'), u'\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.decode) - self.assertEquals(codecs.decode('abc'), u'abc') + self.assertEqual(codecs.decode('abc'), u'abc') self.assertRaises(UnicodeDecodeError, codecs.decode, '\xff', 'ascii') def test_encode(self): - self.assertEquals(codecs.encode(u'\xe4\xf6\xfc', 'latin-1'), + self.assertEqual(codecs.encode(u'\xe4\xf6\xfc', 'latin-1'), '\xe4\xf6\xfc') self.assertRaises(TypeError, codecs.encode) self.assertRaises(LookupError, codecs.encode, "foo", "__spam__") - self.assertEquals(codecs.encode(u'abc'), 'abc') + self.assertEqual(codecs.encode(u'abc'), 'abc') self.assertRaises(UnicodeEncodeError, codecs.encode, u'\xffff', 'ascii') def test_register(self): @@ -1163,19 +1163,19 @@ class StreamReaderTest(unittest.TestCase): def test_readlines(self): f = self.reader(self.stream) - self.assertEquals(f.readlines(), [u'\ud55c\n', u'\uae00']) + self.assertEqual(f.readlines(), [u'\ud55c\n', u'\uae00']) class EncodedFileTest(unittest.TestCase): def test_basic(self): f = StringIO.StringIO('\xed\x95\x9c\n\xea\xb8\x80') ef = codecs.EncodedFile(f, 'utf-16-le', 'utf-8') - self.assertEquals(ef.read(), '\\\xd5\n\x00\x00\xae') + self.assertEqual(ef.read(), '\\\xd5\n\x00\x00\xae') f = StringIO.StringIO() ef = codecs.EncodedFile(f, 'utf-8', 'latin1') ef.write('\xc3\xbc') - self.assertEquals(f.getvalue(), '\xfc') + self.assertEqual(f.getvalue(), '\xfc') class Str2StrTest(unittest.TestCase): @@ -1478,33 +1478,33 @@ class BasicStrTest(unittest.TestCase): class CharmapTest(unittest.TestCase): def test_decode_with_string_map(self): - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "strict", u"abc"), (u"abc", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "replace", u"ab"), (u"ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "replace", u"ab\ufffe"), (u"ab\ufffd", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "ignore", u"ab"), (u"ab", 3) ) - self.assertEquals( + self.assertEqual( codecs.charmap_decode("\x00\x01\x02", "ignore", u"ab\ufffe"), (u"ab", 3) ) allbytes = "".join(chr(i) for i in xrange(256)) - self.assertEquals( + self.assertEqual( codecs.charmap_decode(allbytes, "ignore", u""), (u"", len(allbytes)) ) @@ -1513,14 +1513,14 @@ class WithStmtTest(unittest.TestCase): def test_encodedfile(self): f = StringIO.StringIO("\xc3\xbc") with codecs.EncodedFile(f, "latin-1", "utf-8") as ef: - self.assertEquals(ef.read(), "\xfc") + self.assertEqual(ef.read(), "\xfc") def test_streamreaderwriter(self): f = StringIO.StringIO("\xc3\xbc") info = codecs.lookup("utf-8") with codecs.StreamReaderWriter(f, info.streamreader, info.streamwriter, 'strict') as srw: - self.assertEquals(srw.read(), u"\xfc") + self.assertEqual(srw.read(), u"\xfc") class BomTest(unittest.TestCase): @@ -1538,27 +1538,27 @@ class BomTest(unittest.TestCase): f.write(data) f.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) # Check that the BOM is written after a seek(0) with codecs.open(test_support.TESTFN, 'w+', encoding=encoding) as f: f.write(data[0]) - self.assertNotEquals(f.tell(), 0) + self.assertNotEqual(f.tell(), 0) f.seek(0) f.write(data) f.seek(0) - self.assertEquals(f.read(), data) + self.assertEqual(f.read(), data) # (StreamWriter) Check that the BOM is written after a seek(0) with codecs.open(test_support.TESTFN, 'w+', encoding=encoding) as f: f.writer.write(data[0]) - self.assertNotEquals(f.writer.tell(), 0) + self.assertNotEqual(f.writer.tell(), 0) f.writer.seek(0) f.writer.write(data) f.seek(0) - self.assertEquals(f.read(), data) + self.assertEqual(f.read(), data) # Check that the BOM is not written after a seek() at a position # different than the start @@ -1567,7 +1567,7 @@ class BomTest(unittest.TestCase): f.seek(f.tell()) f.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) # (StreamWriter) Check that the BOM is not written after a seek() # at a position different than the start @@ -1576,7 +1576,7 @@ class BomTest(unittest.TestCase): f.writer.seek(f.writer.tell()) f.writer.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) def test_main(): diff --git a/Lib/test/test_codeop.py b/Lib/test/test_codeop.py index da3b83f..99fe6f9 100644 --- a/Lib/test/test_codeop.py +++ b/Lib/test/test_codeop.py @@ -37,14 +37,14 @@ class CodeopTests(unittest.TestCase): ctx = {'a': 2} d = { 'value': eval(code,ctx) } r = { 'value': eval(str,ctx) } - self.assertEquals(unify_callables(r),unify_callables(d)) + self.assertEqual(unify_callables(r),unify_callables(d)) else: expected = compile(str, "", symbol, PyCF_DONT_IMPLY_DEDENT) - self.assertEquals( compile_command(str, "", symbol), expected) + self.assertEqual(compile_command(str, "", 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", "", 'single', - PyCF_DONT_IMPLY_DEDENT)) - self.assertEquals(compile_command("\n"), - compile("pass", "", 'single', - PyCF_DONT_IMPLY_DEDENT)) + self.assertEqual(compile_command(""), + compile("pass", "", 'single', + PyCF_DONT_IMPLY_DEDENT)) + self.assertEqual(compile_command("\n"), + compile("pass", "", 'single', + PyCF_DONT_IMPLY_DEDENT)) else: av("") av("\n") @@ -290,10 +290,10 @@ class CodeopTests(unittest.TestCase): ai("[i for i in range(10)] = (1, 2, 3)") def test_filename(self): - self.assertEquals(compile_command("a = 1\n", "abc").co_filename, - compile("a = 1\n", "abc", 'single').co_filename) - self.assertNotEquals(compile_command("a = 1\n", "abc").co_filename, - compile("a = 1\n", "def", 'single').co_filename) + self.assertEqual(compile_command("a = 1\n", "abc").co_filename, + compile("a = 1\n", "abc", 'single').co_filename) + self.assertNotEqual(compile_command("a = 1\n", "abc").co_filename, + compile("a = 1\n", "def", 'single').co_filename) def test_main(): diff --git a/Lib/test/test_coercion.py b/Lib/test/test_coercion.py index 0ca00a6..2b55c41 100644 --- a/Lib/test/test_coercion.py +++ b/Lib/test/test_coercion.py @@ -266,9 +266,9 @@ class CoercionTest(unittest.TestCase): self.assertRaises(TypeError, eval, 'a %s b' % op, {'a': a, 'b': b}) else: - self.assertEquals(format_result(res), - format_result(eval('a %s b' % op)), - '%s %s %s == %s failed' % (a, op, b, res)) + self.assertEqual(format_result(res), + format_result(eval('a %s b' % op)), + '%s %s %s == %s failed' % (a, op, b, res)) try: z = copy.copy(a) except copy.Error: @@ -282,7 +282,7 @@ class CoercionTest(unittest.TestCase): self.fail("TypeError not raised") else: exec('z %s= b' % op) - self.assertEquals(ires, z) + self.assertEqual(ires, z) def test_prefix_binops(self): for ia, a in enumerate(candidates): @@ -293,9 +293,9 @@ class CoercionTest(unittest.TestCase): self.assertRaises(TypeError, eval, '%s(a, b)' % op, {'a': a, 'b': b}) else: - self.assertEquals(format_result(res), - format_result(eval('%s(a, b)' % op)), - '%s(%s, %s) == %s failed' % (op, a, b, res)) + self.assertEqual(format_result(res), + format_result(eval('%s(a, b)' % op)), + '%s(%s, %s) == %s failed' % (op, a, b, res)) def test_cmptypes(self): # Built-in tp_compare slots expect their arguments to have the @@ -303,21 +303,21 @@ class CoercionTest(unittest.TestCase): # SF #980352 evil_coercer = CoerceTo(42) # Make sure these don't crash any more - self.assertNotEquals(cmp(u'fish', evil_coercer), 0) - self.assertNotEquals(cmp(slice(1), evil_coercer), 0) + self.assertNotEqual(cmp(u'fish', evil_coercer), 0) + self.assertNotEqual(cmp(slice(1), evil_coercer), 0) # ...but that this still works class WackyComparer(object): def __cmp__(slf, other): self.assertTrue(other == 42, 'expected evil_coercer, got %r' % other) return 0 __hash__ = None # Invalid cmp makes this unhashable - self.assertEquals(cmp(WackyComparer(), evil_coercer), 0) + self.assertEqual(cmp(WackyComparer(), evil_coercer), 0) # ...and classic classes too, since that code path is a little different class ClassicWackyComparer: def __cmp__(slf, other): self.assertTrue(other == 42, 'expected evil_coercer, got %r' % other) return 0 - self.assertEquals(cmp(ClassicWackyComparer(), evil_coercer), 0) + self.assertEqual(cmp(ClassicWackyComparer(), evil_coercer), 0) def test_infinite_rec_classic_classes(self): # if __coerce__() returns its arguments reversed it causes an infinite diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index 3f24008..94305ab 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -674,9 +674,9 @@ class TestCounter(unittest.TestCase): ]): msg = (i, dup, words) self.assertTrue(dup is not words) - self.assertEquals(dup, words) - self.assertEquals(len(dup), len(words)) - self.assertEquals(type(dup), type(words)) + self.assertEqual(dup, words) + self.assertEqual(len(dup), len(words)) + self.assertEqual(type(dup), type(words)) def test_conversions(self): # Convert to: set, list, dict @@ -897,10 +897,10 @@ class TestOrderedDict(unittest.TestCase): OrderedDict(od), ]): self.assertTrue(dup is not od) - self.assertEquals(dup, od) - self.assertEquals(list(dup.items()), list(od.items())) - self.assertEquals(len(dup), len(od)) - self.assertEquals(type(dup), type(od)) + self.assertEqual(dup, od) + self.assertEqual(list(dup.items()), list(od.items())) + self.assertEqual(len(dup), len(od)) + self.assertEqual(type(dup), type(od)) def test_yaml_linkage(self): # Verify that __reduce__ is setup in a way that supports PyYAML's dump() feature. diff --git a/Lib/test/test_commands.py b/Lib/test/test_commands.py index 2d10dea..70cfb58 100644 --- a/Lib/test/test_commands.py +++ b/Lib/test/test_commands.py @@ -24,8 +24,8 @@ if os.name != 'posix': class CommandTests(unittest.TestCase): def test_getoutput(self): - self.assertEquals(commands.getoutput('echo xyzzy'), 'xyzzy') - self.assertEquals(commands.getstatusoutput('echo xyzzy'), (0, 'xyzzy')) + self.assertEqual(commands.getoutput('echo xyzzy'), 'xyzzy') + self.assertEqual(commands.getstatusoutput('echo xyzzy'), (0, 'xyzzy')) # we use mkdtemp in the next line to create an empty directory # under our exclusive control; from that, we can invent a pathname @@ -36,7 +36,7 @@ class CommandTests(unittest.TestCase): name = os.path.join(dir, "foo") status, output = commands.getstatusoutput('cat ' + name) - self.assertNotEquals(status, 0) + self.assertNotEqual(status, 0) finally: if dir is not None: os.rmdir(dir) diff --git a/Lib/test/test_compiler.py b/Lib/test/test_compiler.py index e36a355..332e0bb 100644 --- a/Lib/test/test_compiler.py +++ b/Lib/test/test_compiler.py @@ -81,8 +81,8 @@ class CompilerTest(unittest.TestCase): "", "exec") dct = {} exec c in dct - self.assertEquals(dct.get('e'), 1) - self.assertEquals(dct.get('f'), 1) + self.assertEqual(dct.get('e'), 1) + self.assertEqual(dct.get('f'), 1) def testDefaultArgs(self): self.assertRaises(SyntaxError, compiler.parse, "def foo(a=1, b): pass") @@ -93,7 +93,7 @@ class CompilerTest(unittest.TestCase): c = compiler.compile('def f():\n "doc"', '', 'exec') g = {} exec c in g - self.assertEquals(g['f'].__doc__, "doc") + self.assertEqual(g['f'].__doc__, "doc") def testLineNo(self): # Test that all nodes except Module have a correct lineno attribute. @@ -120,8 +120,8 @@ class CompilerTest(unittest.TestCase): self.check_lineno(child) def testFlatten(self): - self.assertEquals(flatten([1, [2]]), [1, 2]) - self.assertEquals(flatten((1, (2,))), [1, 2]) + self.assertEqual(flatten([1, [2]]), [1, 2]) + self.assertEqual(flatten((1, (2,))), [1, 2]) def testNestedScope(self): c = compiler.compile('def g():\n' @@ -133,44 +133,44 @@ class CompilerTest(unittest.TestCase): 'exec') dct = {} exec c in dct - self.assertEquals(dct.get('result'), 3) + self.assertEqual(dct.get('result'), 3) def testGenExp(self): c = compiler.compile('list((i,j) for i in range(3) if i < 3' ' for j in range(4) if j > 2)', '', 'eval') - self.assertEquals(eval(c), [(0, 3), (1, 3), (2, 3)]) + self.assertEqual(eval(c), [(0, 3), (1, 3), (2, 3)]) def testSetLiteral(self): c = compiler.compile('{1, 2, 3}', '', 'eval') - self.assertEquals(eval(c), {1,2,3}) + self.assertEqual(eval(c), {1,2,3}) c = compiler.compile('{1, 2, 3,}', '', 'eval') - self.assertEquals(eval(c), {1,2,3}) + self.assertEqual(eval(c), {1,2,3}) def testDictLiteral(self): c = compiler.compile('{1:2, 2:3, 3:4}', '', 'eval') - self.assertEquals(eval(c), {1:2, 2:3, 3:4}) + self.assertEqual(eval(c), {1:2, 2:3, 3:4}) c = compiler.compile('{1:2, 2:3, 3:4,}', '', 'eval') - self.assertEquals(eval(c), {1:2, 2:3, 3:4}) + self.assertEqual(eval(c), {1:2, 2:3, 3:4}) def testSetComp(self): c = compiler.compile('{x for x in range(1, 4)}', '', 'eval') - self.assertEquals(eval(c), {1, 2, 3}) + self.assertEqual(eval(c), {1, 2, 3}) c = compiler.compile('{x * y for x in range(3) if x != 0' ' for y in range(4) if y != 0}', '', 'eval') - self.assertEquals(eval(c), {1, 2, 3, 4, 6}) + self.assertEqual(eval(c), {1, 2, 3, 4, 6}) def testDictComp(self): c = compiler.compile('{x:x+1 for x in range(1, 4)}', '', 'eval') - self.assertEquals(eval(c), {1:2, 2:3, 3:4}) + self.assertEqual(eval(c), {1:2, 2:3, 3:4}) c = compiler.compile('{(x, y) : y for x in range(2) if x != 0' ' for y in range(3) if y != 0}', '', 'eval') - self.assertEquals(eval(c), {(1, 2): 2, (1, 1): 1}) + self.assertEqual(eval(c), {(1, 2): 2, (1, 1): 1}) def testWith(self): # SF bug 1638243 @@ -183,7 +183,7 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'TrivialContext': TrivialContext} exec c in dct - self.assertEquals(dct.get('result'), 1) + self.assertEqual(dct.get('result'), 1) def testWithAss(self): c = compiler.compile('from __future__ import with_statement\n' @@ -195,7 +195,7 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'TrivialContext': TrivialContext} exec c in dct - self.assertEquals(dct.get('result'), 1) + self.assertEqual(dct.get('result'), 1) def testWithMult(self): events = [] @@ -215,8 +215,8 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'Ctx': Ctx} exec c in dct - self.assertEquals(dct.get('result'), 1) - self.assertEquals(events, [1, 2]) + self.assertEqual(dct.get('result'), 1) + self.assertEqual(events, [1, 2]) def testGlobal(self): code = compiler.compile('global x\nx=1', '', 'exec') @@ -224,7 +224,7 @@ class CompilerTest(unittest.TestCase): d2 = {} exec code in d1, d2 # x should be in the globals dict - self.assertEquals(d1.get('x'), 1) + self.assertEqual(d1.get('x'), 1) def testPrintFunction(self): c = compiler.compile('from __future__ import print_function\n' @@ -234,14 +234,14 @@ class CompilerTest(unittest.TestCase): 'exec' ) dct = {'output': StringIO()} exec c in dct - self.assertEquals(dct['output'].getvalue(), 'a**b++') + self.assertEqual(dct['output'].getvalue(), 'a**b++') def _testErrEnc(self, src, text, offset): try: compile(src, "", "exec") except SyntaxError, e: - self.assertEquals(e.offset, offset) - self.assertEquals(e.text, text) + self.assertEqual(e.offset, offset) + self.assertEqual(e.text, text) def testSourceCodeEncodingsError(self): # Test SyntaxError with encoding definition diff --git a/Lib/test/test_complex.py b/Lib/test/test_complex.py index a459f84..59e8677 100644 --- a/Lib/test/test_complex.py +++ b/Lib/test/test_complex.py @@ -501,8 +501,8 @@ class ComplexTest(unittest.TestCase): def test_plus_minus_0j(self): # test that -0j and 0j literals are not identified z1, z2 = 0j, -0j - self.assertEquals(atan2(z1.imag, -1.), atan2(0., -1.)) - self.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.)) + self.assertEqual(atan2(z1.imag, -1.), atan2(0., -1.)) + self.assertEqual(atan2(z2.imag, -1.), atan2(-0., -1.)) @unittest.skipUnless(float.__getformat__("double").startswith("IEEE"), "test requires IEEE 754 doubles") diff --git a/Lib/test/test_cookielib.py b/Lib/test/test_cookielib.py index 62a275b..dd0ad32 100644 --- a/Lib/test/test_cookielib.py +++ b/Lib/test/test_cookielib.py @@ -18,10 +18,10 @@ class DateTimeTests(TestCase): base = 1019227000 day = 24*3600 - self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z") - self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z") - self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z") - self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z") + self.assertEqual(time2isoz(base), "2002-04-19 14:36:40Z") + self.assertEqual(time2isoz(base+day), "2002-04-20 14:36:40Z") + self.assertEqual(time2isoz(base+2*day), "2002-04-21 14:36:40Z") + self.assertEqual(time2isoz(base+3*day), "2002-04-22 14:36:40Z") az = time2isoz() bz = time2isoz(500000) @@ -35,13 +35,13 @@ class DateTimeTests(TestCase): def parse_date(text): return time.gmtime(http2time(text))[:6] - self.assertEquals(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0)) + self.assertEqual(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0)) # this test will break around year 2070 - self.assertEquals(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0)) + self.assertEqual(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0)) # this test will break around year 2048 - self.assertEquals(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0)) + self.assertEqual(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0)) def test_http2time_formats(self): from cookielib import http2time, time2isoz @@ -71,8 +71,8 @@ class DateTimeTests(TestCase): test_t = 760233600 # assume broken POSIX counting of seconds result = time2isoz(test_t) expected = "1994-02-03 00:00:00Z" - self.assertEquals(result, expected, - "%s => '%s' (%s)" % (test_t, result, expected)) + self.assertEqual(result, expected, + "%s => '%s' (%s)" % (test_t, result, expected)) for s in tests: t = http2time(s) @@ -114,7 +114,7 @@ class HeaderTests(TestCase): 'foo=bar; expires=01 Jan 2040 22:23:32 GMT', 'foo=bar; expires="01 Jan 2040 22:23:32 GMT"', ]: - self.assertEquals(parse_ns_headers([hdr]), expected) + self.assertEqual(parse_ns_headers([hdr]), expected) def test_parse_ns_headers_version(self): from cookielib import parse_ns_headers @@ -125,7 +125,7 @@ class HeaderTests(TestCase): 'foo=bar; version="1"', 'foo=bar; Version="1"', ]: - self.assertEquals(parse_ns_headers([hdr]), expected) + self.assertEqual(parse_ns_headers([hdr]), expected) def test_parse_ns_headers_special_names(self): # names such as 'expires' are not special in first name=value pair @@ -135,15 +135,15 @@ class HeaderTests(TestCase): # Cookie with name 'expires' hdr = 'expires=01 Jan 2040 22:23:32 GMT' expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]] - self.assertEquals(parse_ns_headers([hdr]), expected) + self.assertEqual(parse_ns_headers([hdr]), expected) def test_join_header_words(self): from cookielib import join_header_words joined = join_header_words([[("foo", None), ("bar", "baz")]]) - self.assertEquals(joined, "foo; bar=baz") + self.assertEqual(joined, "foo; bar=baz") - self.assertEquals(join_header_words([[]]), "") + self.assertEqual(join_header_words([[]]), "") def test_split_header_words(self): from cookielib import split_header_words @@ -175,7 +175,7 @@ class HeaderTests(TestCase): f = StringIO.StringIO() traceback.print_exc(None, f) result = "(error -- traceback follows)\n\n%s" % f.getvalue() - self.assertEquals(result, expect, """ + self.assertEqual(result, expect, """ When parsing: '%s' Expected: '%s' Got: '%s' @@ -209,7 +209,7 @@ Got: '%s' for arg, expect in tests: input = split_header_words([arg]) res = join_header_words(input) - self.assertEquals(res, expect, """ + self.assertEqual(res, expect, """ When parsing: '%s' Expected: '%s' Got: '%s' @@ -380,11 +380,11 @@ class CookieTests(TestCase): interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/') cookie = c._cookies["www.acme.com"]["/"]["eggs"] self.assertTrue(cookie.value is None) - self.assertEquals(cookie.name, "eggs") + self.assertEqual(cookie.name, "eggs") cookie = c._cookies["www.acme.com"]['/foo/']['"spam"'] self.assertTrue(cookie.value is None) - self.assertEquals(cookie.name, '"spam"') - self.assertEquals(lwp_cookie_str(cookie), ( + self.assertEqual(cookie.name, '"spam"') + self.assertEqual(lwp_cookie_str(cookie), ( r'"spam"; path="/foo/"; domain="www.acme.com"; ' 'path_spec; discard; version=0')) old_str = repr(c) @@ -395,13 +395,13 @@ class CookieTests(TestCase): finally: os.unlink(c.filename) # cookies unchanged apart from lost info re. whether path was specified - self.assertEquals( + self.assertEqual( repr(c), re.sub("path_specified=%s" % True, "path_specified=%s" % False, old_str) ) - self.assertEquals(interact_netscape(c, "http://www.acme.com/foo/"), - '"spam"; eggs') + self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"), + '"spam"; eggs') def test_rfc2109_handling(self): # RFC 2109 cookies are handled as RFC 2965 or Netscape cookies, @@ -449,18 +449,18 @@ class CookieTests(TestCase): 'expires="Foo Bar 25 33:22:11 3022"') cookie = c._cookies[".acme.com"]["/"]["spam"] - self.assertEquals(cookie.domain, ".acme.com") + self.assertEqual(cookie.domain, ".acme.com") self.assertTrue(cookie.domain_specified) - self.assertEquals(cookie.port, DEFAULT_HTTP_PORT) + self.assertEqual(cookie.port, DEFAULT_HTTP_PORT) self.assertTrue(not cookie.port_specified) # case is preserved self.assertTrue(cookie.has_nonstandard_attr("blArgh") and not cookie.has_nonstandard_attr("blargh")) cookie = c._cookies["www.acme.com"]["/"]["ni"] - self.assertEquals(cookie.domain, "www.acme.com") + self.assertEqual(cookie.domain, "www.acme.com") self.assertTrue(not cookie.domain_specified) - self.assertEquals(cookie.port, "80,8080") + self.assertEqual(cookie.port, "80,8080") self.assertTrue(cookie.port_specified) cookie = c._cookies["www.acme.com"]["/"]["nini"] @@ -494,13 +494,13 @@ class CookieTests(TestCase): future = time2netscape(time.time()+3600) interact_netscape(c, "http://www.acme.com/", 'spam="bar"; expires=%s' % future) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) now = time2netscape(time.time()-1) # ... and if in past or present, discard it interact_netscape(c, "http://www.acme.com/", 'foo="eggs"; expires=%s' % now) h = interact_netscape(c, "http://www.acme.com/") - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) self.assertTrue('spam="bar"' in h and "foo" not in h) # max-age takes precedence over expires, and zero max-age is request to @@ -509,19 +509,19 @@ class CookieTests(TestCase): future) interact_netscape(c, "http://www.acme.com/", 'bar="bar"; expires=%s' % future) - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; ' 'expires=%s; max-age=0' % future) interact_netscape(c, "http://www.acme.com/", 'bar="bar"; ' 'max-age=0; expires=%s' % future) h = interact_netscape(c, "http://www.acme.com/") - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # test expiry at end of session for cookies with no expires attribute interact_netscape(c, "http://www.rhubarb.net/", 'whum="fizz"') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) c.clear_session_cookies() - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) self.assertIn('spam="bar"', h) # XXX RFC 2965 expiry rules (some apply to V0 too) @@ -576,7 +576,7 @@ class CookieTests(TestCase): # default path does not include query, so is "/", not "/?spam" self.assertIn("/", cj._cookies["example.com"]) # cookie is sent back to the same URI - self.assertEquals(interact_netscape(cj, uri), value) + self.assertEqual(interact_netscape(cj, uri), value) def test_escape_path(self): from cookielib import escape_path @@ -600,7 +600,7 @@ class CookieTests(TestCase): (u"/foo/bar\uabcd", "/foo/bar%EA%AF%8D"), # UTF-8 encoded ] for arg, result in cases: - self.assertEquals(escape_path(arg), result) + self.assertEqual(escape_path(arg), result) def test_request_path(self): from urllib2 import Request @@ -608,25 +608,25 @@ class CookieTests(TestCase): # with parameters req = Request("http://www.example.com/rheum/rhaponticum;" "foo=bar;sing=song?apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), - "/rheum/rhaponticum;foo=bar;sing=song") + self.assertEqual(request_path(req), + "/rheum/rhaponticum;foo=bar;sing=song") # without parameters req = Request("http://www.example.com/rheum/rhaponticum?" "apples=pears&spam=eggs#ni") - self.assertEquals(request_path(req), "/rheum/rhaponticum") + self.assertEqual(request_path(req), "/rheum/rhaponticum") # missing final slash req = Request("http://www.example.com") - self.assertEquals(request_path(req), "/") + self.assertEqual(request_path(req), "/") def test_request_port(self): from urllib2 import Request from cookielib import request_port, DEFAULT_HTTP_PORT req = Request("http://www.acme.com:1234/", headers={"Host": "www.acme.com:4321"}) - self.assertEquals(request_port(req), "1234") + self.assertEqual(request_port(req), "1234") req = Request("http://www.acme.com/", headers={"Host": "www.acme.com:4321"}) - self.assertEquals(request_port(req), DEFAULT_HTTP_PORT) + self.assertEqual(request_port(req), DEFAULT_HTTP_PORT) def test_request_host(self): from urllib2 import Request @@ -636,20 +636,20 @@ class CookieTests(TestCase): headers={"Host": "www.acme.com:80"}) # libwww-perl wants this response, but that seems wrong (RFC 2616, # section 5.2, point 1., and RFC 2965 section 1, paragraph 3) - #self.assertEquals(request_host(req), "www.acme.com") - self.assertEquals(request_host(req), "1.1.1.1") + #self.assertEqual(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "1.1.1.1") req = Request("http://www.acme.com/", headers={"Host": "irrelevant.com"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") # not actually sure this one is valid Request object, so maybe should # remove test for no host in url in request_host function? req = Request("/resource.html", headers={"Host": "www.acme.com"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") # port shouldn't be in request-host req = Request("http://www.acme.com:2345/resource.html", headers={"Host": "www.acme.com:5432"}) - self.assertEquals(request_host(req), "www.acme.com") + self.assertEqual(request_host(req), "www.acme.com") def test_is_HDN(self): from cookielib import is_HDN @@ -664,14 +664,14 @@ class CookieTests(TestCase): def test_reach(self): from cookielib import reach - self.assertEquals(reach("www.acme.com"), ".acme.com") - self.assertEquals(reach("acme.com"), "acme.com") - self.assertEquals(reach("acme.local"), ".local") - self.assertEquals(reach(".local"), ".local") - self.assertEquals(reach(".com"), ".com") - self.assertEquals(reach("."), ".") - self.assertEquals(reach(""), "") - self.assertEquals(reach("192.168.0.1"), "192.168.0.1") + self.assertEqual(reach("www.acme.com"), ".acme.com") + self.assertEqual(reach("acme.com"), "acme.com") + self.assertEqual(reach("acme.local"), ".local") + self.assertEqual(reach(".local"), ".local") + self.assertEqual(reach(".com"), ".com") + self.assertEqual(reach("."), ".") + self.assertEqual(reach(""), "") + self.assertEqual(reach("192.168.0.1"), "192.168.0.1") def test_domain_match(self): from cookielib import domain_match, user_domain_match @@ -719,7 +719,7 @@ class CookieTests(TestCase): c = CookieJar() interact_2965(c, "http://www.nasty.com/", 'foo=bar; domain=friendly.org; Version="1"') - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) def test_strict_domain(self): # Cookies whose domain is a country-code tld like .co.uk should @@ -731,11 +731,11 @@ class CookieTests(TestCase): interact_netscape(cj, "http://example.co.uk/", 'no=problemo') interact_netscape(cj, "http://example.co.uk/", 'okey=dokey; Domain=.example.co.uk') - self.assertEquals(len(cj), 2) + self.assertEqual(len(cj), 2) for pseudo_tld in [".co.uk", ".org.za", ".tx.us", ".name.us"]: interact_netscape(cj, "http://example.%s/" % pseudo_tld, 'spam=eggs; Domain=.co.uk') - self.assertEquals(len(cj), 2) + self.assertEqual(len(cj), 2) def test_two_component_domain_ns(self): # Netscape: .www.bar.com, www.bar.com, .bar.com, bar.com, no domain @@ -747,17 +747,17 @@ class CookieTests(TestCase): # two-component V0 domain is OK interact_netscape(c, "http://foo.net/", 'ns=bar') - self.assertEquals(len(c), 1) - self.assertEquals(c._cookies["foo.net"]["/"]["ns"].value, "bar") - self.assertEquals(interact_netscape(c, "http://foo.net/"), "ns=bar") + self.assertEqual(len(c), 1) + self.assertEqual(c._cookies["foo.net"]["/"]["ns"].value, "bar") + self.assertEqual(interact_netscape(c, "http://foo.net/"), "ns=bar") # *will* be returned to any other domain (unlike RFC 2965)... - self.assertEquals(interact_netscape(c, "http://www.foo.net/"), - "ns=bar") + self.assertEqual(interact_netscape(c, "http://www.foo.net/"), + "ns=bar") # ...unless requested otherwise pol = DefaultCookiePolicy( strict_ns_domain=DefaultCookiePolicy.DomainStrictNonDomain) c.set_policy(pol) - self.assertEquals(interact_netscape(c, "http://www.foo.net/"), "") + self.assertEqual(interact_netscape(c, "http://www.foo.net/"), "") # unlike RFC 2965, even explicit two-component domain is OK, # because .foo.net matches foo.net @@ -766,17 +766,17 @@ class CookieTests(TestCase): # even if starts with a dot -- in NS rules, .foo.net matches foo.net! interact_netscape(c, "http://foo.net/foo/bar/", 'spam2=eggs; domain=.foo.net') - self.assertEquals(len(c), 3) - self.assertEquals(c._cookies[".foo.net"]["/foo"]["spam1"].value, - "eggs") - self.assertEquals(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value, - "eggs") - self.assertEquals(interact_netscape(c, "http://foo.net/foo/bar/"), - "spam2=eggs; spam1=eggs; ns=bar") + self.assertEqual(len(c), 3) + self.assertEqual(c._cookies[".foo.net"]["/foo"]["spam1"].value, + "eggs") + self.assertEqual(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value, + "eggs") + self.assertEqual(interact_netscape(c, "http://foo.net/foo/bar/"), + "spam2=eggs; spam1=eggs; ns=bar") # top-level domain is too general interact_netscape(c, "http://foo.net/", 'nini="ni"; domain=.net') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) ## # Netscape protocol doesn't allow non-special top level domains (such ## # as co.uk) in the domain attribute unless there are at least three @@ -784,8 +784,8 @@ class CookieTests(TestCase): # Oh yes it does! Real implementations don't check this, and real # cookies (of course) rely on that behaviour. interact_netscape(c, "http://foo.co.uk", 'nasty=trick; domain=.co.uk') -## self.assertEquals(len(c), 2) - self.assertEquals(len(c), 4) +## self.assertEqual(len(c), 2) + self.assertEqual(len(c), 4) def test_two_component_domain_rfc2965(self): from cookielib import CookieJar, DefaultCookiePolicy @@ -795,43 +795,43 @@ class CookieTests(TestCase): # two-component V1 domain is OK interact_2965(c, "http://foo.net/", 'foo=bar; Version="1"') - self.assertEquals(len(c), 1) - self.assertEquals(c._cookies["foo.net"]["/"]["foo"].value, "bar") - self.assertEquals(interact_2965(c, "http://foo.net/"), - "$Version=1; foo=bar") + self.assertEqual(len(c), 1) + self.assertEqual(c._cookies["foo.net"]["/"]["foo"].value, "bar") + self.assertEqual(interact_2965(c, "http://foo.net/"), + "$Version=1; foo=bar") # won't be returned to any other domain (because domain was implied) - self.assertEquals(interact_2965(c, "http://www.foo.net/"), "") + self.assertEqual(interact_2965(c, "http://www.foo.net/"), "") # unless domain is given explicitly, because then it must be # rewritten to start with a dot: foo.net --> .foo.net, which does # not domain-match foo.net interact_2965(c, "http://foo.net/foo", 'spam=eggs; domain=foo.net; path=/foo; Version="1"') - self.assertEquals(len(c), 1) - self.assertEquals(interact_2965(c, "http://foo.net/foo"), - "$Version=1; foo=bar") + self.assertEqual(len(c), 1) + self.assertEqual(interact_2965(c, "http://foo.net/foo"), + "$Version=1; foo=bar") # explicit foo.net from three-component domain www.foo.net *does* get # set, because .foo.net domain-matches .foo.net interact_2965(c, "http://www.foo.net/foo/", 'spam=eggs; domain=foo.net; Version="1"') - self.assertEquals(c._cookies[".foo.net"]["/foo/"]["spam"].value, - "eggs") - self.assertEquals(len(c), 2) - self.assertEquals(interact_2965(c, "http://foo.net/foo/"), - "$Version=1; foo=bar") - self.assertEquals(interact_2965(c, "http://www.foo.net/foo/"), - '$Version=1; spam=eggs; $Domain="foo.net"') + self.assertEqual(c._cookies[".foo.net"]["/foo/"]["spam"].value, + "eggs") + self.assertEqual(len(c), 2) + self.assertEqual(interact_2965(c, "http://foo.net/foo/"), + "$Version=1; foo=bar") + self.assertEqual(interact_2965(c, "http://www.foo.net/foo/"), + '$Version=1; spam=eggs; $Domain="foo.net"') # top-level domain is too general interact_2965(c, "http://foo.net/", 'ni="ni"; domain=".net"; Version="1"') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # RFC 2965 doesn't require blocking this interact_2965(c, "http://foo.co.uk/", 'nasty=trick; domain=.co.uk; Version="1"') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) def test_domain_allow(self): from cookielib import CookieJar, DefaultCookiePolicy @@ -845,24 +845,24 @@ class CookieTests(TestCase): headers = ["Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/"] res = FakeResponse(headers, "http://acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) req = Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) req = Request("http://www.coyote.com/") res = FakeResponse(headers, "http://www.coyote.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # set a cookie with non-allowed domain... req = Request("http://www.coyote.com/") res = FakeResponse(headers, "http://www.coyote.com/") cookies = c.make_cookies(res, req) c.set_cookie(cookies[0]) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) self.assertTrue(not req.has_header("Cookie")) @@ -879,17 +879,17 @@ class CookieTests(TestCase): req = Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") c.extract_cookies(res, req) - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) p = pol.set_blocked_domains(["acme.com"]) c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.clear() req = Request("http://www.roadrunner.net/") res = FakeResponse(headers, "http://www.roadrunner.net/") c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) req = Request("http://www.roadrunner.net/") c.add_cookie_header(req) self.assertTrue((req.has_header("Cookie") and @@ -898,14 +898,14 @@ class CookieTests(TestCase): c.clear() pol.set_blocked_domains([".acme.com"]) c.extract_cookies(res, req) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # set a cookie with blocked domain... req = Request("http://www.acme.com/") res = FakeResponse(headers, "http://www.acme.com/") cookies = c.make_cookies(res, req) c.set_cookie(cookies[0]) - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # ... and check is doesn't get returned c.add_cookie_header(req) self.assertTrue(not req.has_header("Cookie")) @@ -940,7 +940,7 @@ class CookieTests(TestCase): c = CookieJar(policy=DefaultCookiePolicy(rfc2965=True)) interact_2965(c, "http://www.acme.com/", r'foo=\b"a"r; Version=1') h = interact_2965(c, "http://www.acme.com/") - self.assertEquals(h, r'$Version=1; foo=\\b\"a\"r') + self.assertEqual(h, r'$Version=1; foo=\\b\"a\"r') def test_missing_final_slash(self): # Missing slash from request URL's abs_path should be assumed present. @@ -950,7 +950,7 @@ class CookieTests(TestCase): c = CookieJar(DefaultCookiePolicy(rfc2965=True)) interact_2965(c, url, "foo=bar; Version=1") req = Request(url) - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) c.add_cookie_header(req) self.assertTrue(req.has_header("Cookie")) @@ -1070,33 +1070,33 @@ class CookieTests(TestCase): i = 0 for c in cs: self.assertIsInstance(c, Cookie) - self.assertEquals(c.version, versions[i]) - self.assertEquals(c.name, names[i]) - self.assertEquals(c.domain, domains[i]) - self.assertEquals(c.path, paths[i]) + self.assertEqual(c.version, versions[i]) + self.assertEqual(c.name, names[i]) + self.assertEqual(c.domain, domains[i]) + self.assertEqual(c.path, paths[i]) i = i + 1 def test_parse_ns_headers(self): from cookielib import parse_ns_headers # missing domain value (invalid cookie) - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo=bar; path=/; domain"]), [[("foo", "bar"), ("path", "/"), ("domain", None), ("version", "0")]] ) # invalid expires value - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]), [[("foo", "bar"), ("expires", None), ("version", "0")]] ) # missing cookie value (valid cookie) - self.assertEquals( + self.assertEqual( parse_ns_headers(["foo"]), [[("foo", None), ("version", "0")]] ) # shouldn't add version if header is empty - self.assertEquals(parse_ns_headers([""]), []) + self.assertEqual(parse_ns_headers([""]), []) def test_bad_cookie_header(self): @@ -1122,7 +1122,7 @@ class CookieTests(TestCase): ]: c = cookiejar_from_cookie_headers(headers) # these bad cookies shouldn't be set - self.assertEquals(len(c), 0) + self.assertEqual(len(c), 0) # cookie with invalid expires is treated as session cookie headers = ["Set-Cookie: c=foo; expires=Foo Bar 12 33:22:11 2000"] @@ -1267,7 +1267,7 @@ class LWPCookieTests(TestCase): req = Request("http://www.acme.com/") c.add_cookie_header(req) - self.assertEquals(req.get_header("Cookie"), + self.assertEqual(req.get_header("Cookie"), "PART_NUMBER=ROCKET_LAUNCHER_0001") headers.append( @@ -1471,40 +1471,40 @@ class LWPCookieTests(TestCase): # legal domain cookie = interact_2965(c, "http://www.acme.com", 'ping=pong; domain="acme.com"; version=1') - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # illegal domain (host prefix "www.a" contains a dot) cookie = interact_2965(c, "http://www.a.acme.com", 'whiz=bang; domain="acme.com"; version=1') - self.assertEquals(len(c), 1) + self.assertEqual(len(c), 1) # legal domain cookie = interact_2965(c, "http://www.a.acme.com", 'wow=flutter; domain=".a.acme.com"; version=1') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # can't partially match an IP-address cookie = interact_2965(c, "http://125.125.125.125", 'zzzz=ping; domain="125.125.125"; version=1') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # illegal path (must be prefix of request path) cookie = interact_2965(c, "http://www.sol.no", 'blah=rhubarb; domain=".sol.no"; path="/foo"; ' 'version=1') - self.assertEquals(len(c), 2) + self.assertEqual(len(c), 2) # legal path cookie = interact_2965(c, "http://www.sol.no/foo/bar", 'bing=bong; domain=".sol.no"; path="/foo"; ' 'version=1') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) # illegal port (request-port not in list) cookie = interact_2965(c, "http://www.sol.no", 'whiz=ffft; domain=".sol.no"; port="90,100"; ' 'version=1') - self.assertEquals(len(c), 3) + self.assertEqual(len(c), 3) # legal port cookie = interact_2965( @@ -1512,13 +1512,13 @@ class LWPCookieTests(TestCase): r'bang=wallop; version=1; domain=".sol.no"; ' r'port="90,100, 80,8080"; ' r'max-age=100; Comment = "Just kidding! (\"|\\\\) "') - self.assertEquals(len(c), 4) + self.assertEqual(len(c), 4) # port attribute without any value (current port) cookie = interact_2965(c, "http://www.sol.no", 'foo9=bar; version=1; domain=".sol.no"; port; ' 'max-age=100;') - self.assertEquals(len(c), 5) + self.assertEqual(len(c), 5) # encoded path # LWP has this test, but unescaping allowed path characters seems @@ -1529,7 +1529,7 @@ class LWPCookieTests(TestCase): # character: cookie = interact_2965(c, "http://www.sol.no/ 0.01, then - now) now = time.time() @@ -183,7 +183,7 @@ class TestEPoll(unittest.TestCase): (server.fileno(), select.EPOLLIN | select.EPOLLOUT)] expected.sort() - self.assertEquals(events, expected) + self.assertEqual(events, expected) ep.unregister(client.fileno()) ep.modify(server.fileno(), select.EPOLLOUT) @@ -193,7 +193,7 @@ class TestEPoll(unittest.TestCase): self.assertFalse(then - now > 0.01) expected = [(server.fileno(), select.EPOLLOUT)] - self.assertEquals(events, expected) + self.assertEqual(events, expected) def test_errors(self): self.assertRaises(ValueError, select.epoll, -2) diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py index 3ee0856..a19c82d 100644 --- a/Lib/test/test_exceptions.py +++ b/Lib/test/test_exceptions.py @@ -32,8 +32,8 @@ class ExceptionTests(unittest.TestCase): raise exc("spam") except exc, err: buf2 = str(err) - self.assertEquals(buf1, buf2) - self.assertEquals(exc.__name__, excname) + self.assertEqual(buf1, buf2) + self.assertEqual(exc.__name__, excname) def testRaising(self): self.raise_catch(AttributeError, "AttributeError") @@ -163,7 +163,7 @@ class ExceptionTests(unittest.TestCase): except TypeError, err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code - self.assertEquals(co.co_name, "test_capi1") + self.assertEqual(co.co_name, "test_capi1") self.assertTrue(co.co_filename.endswith('test_exceptions'+os.extsep+'py')) else: self.fail("Expected exception") @@ -175,10 +175,10 @@ class ExceptionTests(unittest.TestCase): except RuntimeError, err: exc, err, tb = sys.exc_info() co = tb.tb_frame.f_code - self.assertEquals(co.co_name, "__init__") + self.assertEqual(co.co_name, "__init__") self.assertTrue(co.co_filename.endswith('test_exceptions'+os.extsep+'py')) co2 = tb.tb_frame.f_back.f_code - self.assertEquals(co2.co_name, "test_capi2") + self.assertEqual(co2.co_name, "test_capi2") else: self.fail("Expected exception") @@ -284,14 +284,14 @@ class ExceptionTests(unittest.TestCase): if type(e) is not exc: raise # Verify module name - self.assertEquals(type(e).__module__, 'exceptions') + self.assertEqual(type(e).__module__, 'exceptions') # Verify no ref leaks in Exc_str() s = str(e) for checkArgName in expected: - self.assertEquals(repr(getattr(e, checkArgName)), - repr(expected[checkArgName]), - 'exception "%s", attribute "%s"' % - (repr(e), checkArgName)) + self.assertEqual(repr(getattr(e, checkArgName)), + repr(expected[checkArgName]), + 'exception "%s", attribute "%s"' % + (repr(e), checkArgName)) # test for pickling support for p in pickle, cPickle: @@ -300,9 +300,9 @@ class ExceptionTests(unittest.TestCase): for checkArgName in expected: got = repr(getattr(new, checkArgName)) want = repr(expected[checkArgName]) - self.assertEquals(got, want, - 'pickled "%r", attribute "%s"' % - (e, checkArgName)) + self.assertEqual(got, want, + 'pickled "%r", attribute "%s"' % + (e, checkArgName)) def testDeprecatedMessageAttribute(self): @@ -359,7 +359,7 @@ class ExceptionTests(unittest.TestCase): self.fancy_arg = fancy_arg x = DerivedException(fancy_arg=42) - self.assertEquals(x.fancy_arg, 42) + self.assertEqual(x.fancy_arg, 42) def testInfiniteRecursion(self): def f(): diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py index c3c0def..dffa4b5 100644 --- a/Lib/test/test_file.py +++ b/Lib/test/test_file.py @@ -30,7 +30,7 @@ class AutoFileTests(unittest.TestCase): # verify weak references p = proxy(self.f) p.write(b'teststring') - self.assertEquals(self.f.tell(), p.tell()) + self.assertEqual(self.f.tell(), p.tell()) self.f.close() self.f = None self.assertRaises(ReferenceError, getattr, p, 'tell') @@ -49,7 +49,7 @@ class AutoFileTests(unittest.TestCase): a = array('b', b'x'*10) self.f = self.open(TESTFN, 'rb') n = self.f.readinto(a) - self.assertEquals(b'12', a.tostring()[:n]) + self.assertEqual(b'12', a.tostring()[:n]) def testReadinto_text(self): # verify readinto refuses text files @@ -66,7 +66,7 @@ class AutoFileTests(unittest.TestCase): self.f.close() self.f = self.open(TESTFN, 'rb') buf = self.f.read() - self.assertEquals(buf, b'12') + self.assertEqual(buf, b'12') def testWritelinesIntegers(self): # verify writelines with integers @@ -87,7 +87,7 @@ class AutoFileTests(unittest.TestCase): def testErrors(self): f = self.f - self.assertEquals(f.name, TESTFN) + self.assertEqual(f.name, TESTFN) self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) @@ -124,12 +124,12 @@ class AutoFileTests(unittest.TestCase): self.assertRaises(ValueError, method, *args) # file is closed, __exit__ shouldn't do anything - self.assertEquals(self.f.__exit__(None, None, None), None) + self.assertEqual(self.f.__exit__(None, None, None), None) # it must also return None if an exception was given try: 1 // 0 except: - self.assertEquals(self.f.__exit__(*sys.exc_info()), None) + self.assertEqual(self.f.__exit__(*sys.exc_info()), None) def testReadWhenWriting(self): self.assertRaises(IOError, self.f.read) @@ -195,7 +195,7 @@ class OtherFileTests(unittest.TestCase): f.close() except IOError as msg: self.fail('error setting buffer size %d: %s' % (s, str(msg))) - self.assertEquals(d, s) + self.assertEqual(d, s) def testTruncateOnWindows(self): # SF bug diff --git a/Lib/test/test_file2k.py b/Lib/test/test_file2k.py index ab09f21..399f119 100644 --- a/Lib/test/test_file2k.py +++ b/Lib/test/test_file2k.py @@ -29,7 +29,7 @@ class AutoFileTests(unittest.TestCase): # verify weak references p = proxy(self.f) p.write('teststring') - self.assertEquals(self.f.tell(), p.tell()) + self.assertEqual(self.f.tell(), p.tell()) self.f.close() self.f = None self.assertRaises(ReferenceError, getattr, p, 'tell') @@ -58,7 +58,7 @@ class AutoFileTests(unittest.TestCase): a = array('c', 'x'*10) self.f = open(TESTFN, 'rb') n = self.f.readinto(a) - self.assertEquals('12', a.tostring()[:n]) + self.assertEqual('12', a.tostring()[:n]) def testWritelinesUserList(self): # verify writelines with instance sequence @@ -67,7 +67,7 @@ class AutoFileTests(unittest.TestCase): self.f.close() self.f = open(TESTFN, 'rb') buf = self.f.read() - self.assertEquals(buf, '12') + self.assertEqual(buf, '12') def testWritelinesIntegers(self): # verify writelines with integers @@ -94,7 +94,7 @@ class AutoFileTests(unittest.TestCase): self.f.close() self.f = open(TESTFN, 'rb') f = self.f - self.assertEquals(f.name, TESTFN) + self.assertEqual(f.name, TESTFN) self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) @@ -125,12 +125,12 @@ class AutoFileTests(unittest.TestCase): self.assertRaises(ValueError, self.f.writelines, []) # file is closed, __exit__ shouldn't do anything - self.assertEquals(self.f.__exit__(None, None, None), None) + self.assertEqual(self.f.__exit__(None, None, None), None) # it must also return None if an exception was given try: 1 // 0 except: - self.assertEquals(self.f.__exit__(*sys.exc_info()), None) + self.assertEqual(self.f.__exit__(*sys.exc_info()), None) def testReadWhenWriting(self): self.assertRaises(IOError, self.f.read) @@ -261,7 +261,7 @@ class OtherFileTests(unittest.TestCase): f.close() except IOError, msg: self.fail('error setting buffer size %d: %s' % (s, str(msg))) - self.assertEquals(d, s) + self.assertEqual(d, s) def testTruncateOnWindows(self): os.unlink(TESTFN) @@ -621,7 +621,7 @@ class StdoutTests(unittest.TestCase): try: print except RuntimeError as e: - self.assertEquals(str(e), "lost sys.stdout") + self.assertEqual(str(e), "lost sys.stdout") else: self.fail("Expected RuntimeError") finally: diff --git a/Lib/test/test_fileio.py b/Lib/test/test_fileio.py index a63ba06..9688ffc 100644 --- a/Lib/test/test_fileio.py +++ b/Lib/test/test_fileio.py @@ -31,31 +31,31 @@ class AutoFileTests(unittest.TestCase): # verify weak references p = proxy(self.f) p.write(bytes(range(10))) - self.assertEquals(self.f.tell(), p.tell()) + self.assertEqual(self.f.tell(), p.tell()) self.f.close() self.f = None self.assertRaises(ReferenceError, getattr, p, 'tell') def testSeekTell(self): self.f.write(bytes(range(20))) - self.assertEquals(self.f.tell(), 20) + self.assertEqual(self.f.tell(), 20) self.f.seek(0) - self.assertEquals(self.f.tell(), 0) + self.assertEqual(self.f.tell(), 0) self.f.seek(10) - self.assertEquals(self.f.tell(), 10) + self.assertEqual(self.f.tell(), 10) self.f.seek(5, 1) - self.assertEquals(self.f.tell(), 15) + self.assertEqual(self.f.tell(), 15) self.f.seek(-5, 1) - self.assertEquals(self.f.tell(), 10) + self.assertEqual(self.f.tell(), 10) self.f.seek(-5, 2) - self.assertEquals(self.f.tell(), 15) + self.assertEqual(self.f.tell(), 15) def testAttributes(self): # verify expected attributes exist f = self.f - self.assertEquals(f.mode, "wb") - self.assertEquals(f.closed, False) + self.assertEqual(f.mode, "wb") + self.assertEqual(f.closed, False) # verify the attributes are readonly for attr in 'mode', 'closed': @@ -69,7 +69,7 @@ class AutoFileTests(unittest.TestCase): a = array(b'b', b'x'*10) self.f = _FileIO(TESTFN, 'r') n = self.f.readinto(a) - self.assertEquals(array(b'b', [1, 2]), a[:n]) + self.assertEqual(array(b'b', [1, 2]), a[:n]) def test_none_args(self): self.f.write(b"hi\nbye\nabc") @@ -81,19 +81,19 @@ class AutoFileTests(unittest.TestCase): self.assertEqual(self.f.readlines(None), [b"bye\n", b"abc"]) def testRepr(self): - self.assertEquals(repr(self.f), "<_io.FileIO name=%r mode='%s'>" - % (self.f.name, self.f.mode)) + self.assertEqual(repr(self.f), "<_io.FileIO name=%r mode='%s'>" + % (self.f.name, self.f.mode)) del self.f.name - self.assertEquals(repr(self.f), "<_io.FileIO fd=%r mode='%s'>" - % (self.f.fileno(), self.f.mode)) + self.assertEqual(repr(self.f), "<_io.FileIO fd=%r mode='%s'>" + % (self.f.fileno(), self.f.mode)) self.f.close() - self.assertEquals(repr(self.f), "<_io.FileIO [closed]>") + self.assertEqual(repr(self.f), "<_io.FileIO [closed]>") def testErrors(self): f = self.f self.assertTrue(not f.isatty()) self.assertTrue(not f.closed) - #self.assertEquals(f.name, TESTFN) + #self.assertEqual(f.name, TESTFN) self.assertRaises(ValueError, f.read, 10) # Open for reading f.close() self.assertTrue(f.closed) @@ -236,22 +236,22 @@ class OtherFileTests(unittest.TestCase): def testAbles(self): try: f = _FileIO(TESTFN, "w") - self.assertEquals(f.readable(), False) - self.assertEquals(f.writable(), True) - self.assertEquals(f.seekable(), True) + self.assertEqual(f.readable(), False) + self.assertEqual(f.writable(), True) + self.assertEqual(f.seekable(), True) f.close() f = _FileIO(TESTFN, "r") - self.assertEquals(f.readable(), True) - self.assertEquals(f.writable(), False) - self.assertEquals(f.seekable(), True) + self.assertEqual(f.readable(), True) + self.assertEqual(f.writable(), False) + self.assertEqual(f.seekable(), True) f.close() f = _FileIO(TESTFN, "a+") - self.assertEquals(f.readable(), True) - self.assertEquals(f.writable(), True) - self.assertEquals(f.seekable(), True) - self.assertEquals(f.isatty(), False) + self.assertEqual(f.readable(), True) + self.assertEqual(f.writable(), True) + self.assertEqual(f.seekable(), True) + self.assertEqual(f.isatty(), False) f.close() if sys.platform != "win32": @@ -263,14 +263,14 @@ class OtherFileTests(unittest.TestCase): # OS'es that don't support /dev/tty. pass else: - self.assertEquals(f.readable(), False) - self.assertEquals(f.writable(), True) + self.assertEqual(f.readable(), False) + self.assertEqual(f.writable(), True) if sys.platform != "darwin" and \ 'bsd' not in sys.platform and \ not sys.platform.startswith('sunos'): # Somehow /dev/tty appears seekable on some BSDs - self.assertEquals(f.seekable(), False) - self.assertEquals(f.isatty(), True) + self.assertEqual(f.seekable(), False) + self.assertEqual(f.isatty(), True) f.close() finally: os.unlink(TESTFN) @@ -304,7 +304,7 @@ class OtherFileTests(unittest.TestCase): f.write(b"abc") f.close() with open(TESTFN, "rb") as f: - self.assertEquals(f.read(), b"abc") + self.assertEqual(f.read(), b"abc") finally: os.unlink(TESTFN) diff --git a/Lib/test/test_float.py b/Lib/test/test_float.py index de5ca46..9d68da7 100644 --- a/Lib/test/test_float.py +++ b/Lib/test/test_float.py @@ -473,15 +473,15 @@ class IEEEFormatTestCase(unittest.TestCase): return -0.0, math.atan2(0.0, -1) def neg_neg(): return -0.0, math.atan2(-0.0, -1) - self.assertEquals(pos_pos(), neg_pos()) - self.assertEquals(pos_neg(), neg_neg()) + self.assertEqual(pos_pos(), neg_pos()) + self.assertEqual(pos_neg(), neg_neg()) @requires_IEEE_754 def test_underflow_sign(self): # check that -1e-1000 gives -0.0, not 0.0 - self.assertEquals(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1)) - self.assertEquals(math.atan2(float('-1e-1000'), -1), - math.atan2(-0.0, -1)) + self.assertEqual(math.atan2(-1e-1000, -1), math.atan2(-0.0, -1)) + self.assertEqual(math.atan2(float('-1e-1000'), -1), + math.atan2(-0.0, -1)) def test_format(self): # these should be rewritten to use both format(x, spec) and @@ -556,9 +556,9 @@ class IEEEFormatTestCase(unittest.TestCase): self.assertEqual(fmt % -arg, '-' + rhs) def test_issue5864(self): - self.assertEquals(format(123.456, '.4'), '123.5') - self.assertEquals(format(1234.56, '.4'), '1.235e+03') - self.assertEquals(format(12345.6, '.4'), '1.235e+04') + self.assertEqual(format(123.456, '.4'), '123.5') + self.assertEqual(format(1234.56, '.4'), '1.235e+03') + self.assertEqual(format(12345.6, '.4'), '1.235e+04') class ReprTestCase(unittest.TestCase): def test_repr(self): diff --git a/Lib/test/test_fpformat.py b/Lib/test/test_fpformat.py index a951cd0..e6de3b0 100644 --- a/Lib/test/test_fpformat.py +++ b/Lib/test/test_fpformat.py @@ -26,7 +26,7 @@ class FpformatTest(unittest.TestCase): n = repr(n) expected = "%.*f" % (digits, float(n)) - self.assertEquals(result, expected) + self.assertEqual(result, expected) def checkSci(self, n, digits): result = sci(n, digits) @@ -39,11 +39,11 @@ class FpformatTest(unittest.TestCase): exp = exp[0] + "0" + exp[1:] expected = "%se%s" % (num, exp) - self.assertEquals(result, expected) + self.assertEqual(result, expected) def test_basic_cases(self): - self.assertEquals(fix(100.0/3, 3), '33.333') - self.assertEquals(sci(100.0/3, 3), '3.333e+001') + self.assertEqual(fix(100.0/3, 3), '33.333') + self.assertEqual(sci(100.0/3, 3), '3.333e+001') def test_reasonable_values(self): for d in range(7): @@ -54,12 +54,12 @@ class FpformatTest(unittest.TestCase): def test_failing_values(self): # Now for 'unreasonable n and d' - self.assertEquals(fix(1.0, 1000), '1.'+('0'*1000)) - self.assertEquals(sci("1"+('0'*1000), 0), '1e+1000') + self.assertEqual(fix(1.0, 1000), '1.'+('0'*1000)) + self.assertEqual(sci("1"+('0'*1000), 0), '1e+1000') # This behavior is inconsistent. sci raises an exception; fix doesn't. yacht = "Throatwobbler Mangrove" - self.assertEquals(fix(yacht, 10), yacht) + self.assertEqual(fix(yacht, 10), yacht) try: sci(yacht, 10) except NotANumber: diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py index 7f0c428..a798477 100644 --- a/Lib/test/test_fractions.py +++ b/Lib/test/test_fractions.py @@ -91,16 +91,16 @@ class DummyRational(object): class GcdTest(unittest.TestCase): def testMisc(self): - self.assertEquals(0, gcd(0, 0)) - self.assertEquals(1, gcd(1, 0)) - self.assertEquals(-1, gcd(-1, 0)) - self.assertEquals(1, gcd(0, 1)) - self.assertEquals(-1, gcd(0, -1)) - self.assertEquals(1, gcd(7, 1)) - self.assertEquals(-1, gcd(7, -1)) - self.assertEquals(1, gcd(-23, 15)) - self.assertEquals(12, gcd(120, 84)) - self.assertEquals(-12, gcd(84, -120)) + self.assertEqual(0, gcd(0, 0)) + self.assertEqual(1, gcd(1, 0)) + self.assertEqual(-1, gcd(-1, 0)) + self.assertEqual(1, gcd(0, 1)) + self.assertEqual(-1, gcd(0, -1)) + self.assertEqual(1, gcd(7, 1)) + self.assertEqual(-1, gcd(7, -1)) + self.assertEqual(1, gcd(-23, 15)) + self.assertEqual(12, gcd(120, 84)) + self.assertEqual(-12, gcd(84, -120)) def _components(r): @@ -111,8 +111,8 @@ class FractionTest(unittest.TestCase): def assertTypedEquals(self, expected, actual): """Asserts that both the types and values are the same.""" - self.assertEquals(type(expected), type(actual)) - self.assertEquals(expected, actual) + self.assertEqual(type(expected), type(actual)) + self.assertEqual(expected, actual) def assertRaisesMessage(self, exc_type, message, callable, *args, **kwargs): @@ -120,25 +120,25 @@ class FractionTest(unittest.TestCase): try: callable(*args, **kwargs) except exc_type, e: - self.assertEquals(message, str(e)) + self.assertEqual(message, str(e)) else: self.fail("%s not raised" % exc_type.__name__) def testInit(self): - self.assertEquals((0, 1), _components(F())) - self.assertEquals((7, 1), _components(F(7))) - self.assertEquals((7, 3), _components(F(F(7, 3)))) + self.assertEqual((0, 1), _components(F())) + self.assertEqual((7, 1), _components(F(7))) + self.assertEqual((7, 3), _components(F(F(7, 3)))) - self.assertEquals((-1, 1), _components(F(-1, 1))) - self.assertEquals((-1, 1), _components(F(1, -1))) - self.assertEquals((1, 1), _components(F(-2, -2))) - self.assertEquals((1, 2), _components(F(5, 10))) - self.assertEquals((7, 15), _components(F(7, 15))) - self.assertEquals((10**23, 1), _components(F(10**23))) + self.assertEqual((-1, 1), _components(F(-1, 1))) + self.assertEqual((-1, 1), _components(F(1, -1))) + self.assertEqual((1, 1), _components(F(-2, -2))) + self.assertEqual((1, 2), _components(F(5, 10))) + self.assertEqual((7, 15), _components(F(7, 15))) + self.assertEqual((10**23, 1), _components(F(10**23))) - self.assertEquals((3, 77), _components(F(F(3, 7), 11))) - self.assertEquals((-9, 5), _components(F(2, F(-10, 9)))) - self.assertEquals((2486, 2485), _components(F(F(22, 7), F(355, 113)))) + self.assertEqual((3, 77), _components(F(F(3, 7), 11))) + self.assertEqual((-9, 5), _components(F(2, F(-10, 9)))) + self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113)))) self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)", F, 12, 0) @@ -150,43 +150,43 @@ class FractionTest(unittest.TestCase): @requires_IEEE_754 def testInitFromFloat(self): - self.assertEquals((5, 2), _components(F(2.5))) - self.assertEquals((0, 1), _components(F(-0.0))) - self.assertEquals((3602879701896397, 36028797018963968), - _components(F(0.1))) + self.assertEqual((5, 2), _components(F(2.5))) + self.assertEqual((0, 1), _components(F(-0.0))) + self.assertEqual((3602879701896397, 36028797018963968), + _components(F(0.1))) self.assertRaises(TypeError, F, float('nan')) self.assertRaises(TypeError, F, float('inf')) self.assertRaises(TypeError, F, float('-inf')) def testInitFromDecimal(self): - self.assertEquals((11, 10), - _components(F(Decimal('1.1')))) - self.assertEquals((7, 200), - _components(F(Decimal('3.5e-2')))) - self.assertEquals((0, 1), - _components(F(Decimal('.000e20')))) + self.assertEqual((11, 10), + _components(F(Decimal('1.1')))) + self.assertEqual((7, 200), + _components(F(Decimal('3.5e-2')))) + self.assertEqual((0, 1), + _components(F(Decimal('.000e20')))) self.assertRaises(TypeError, F, Decimal('nan')) self.assertRaises(TypeError, F, Decimal('snan')) self.assertRaises(TypeError, F, Decimal('inf')) self.assertRaises(TypeError, F, Decimal('-inf')) def testFromString(self): - self.assertEquals((5, 1), _components(F("5"))) - self.assertEquals((3, 2), _components(F("3/2"))) - self.assertEquals((3, 2), _components(F(" \n +3/2"))) - self.assertEquals((-3, 2), _components(F("-3/2 "))) - self.assertEquals((13, 2), _components(F(" 013/02 \n "))) - self.assertEquals((13, 2), _components(F(u" 013/02 \n "))) - - self.assertEquals((16, 5), _components(F(" 3.2 "))) - self.assertEquals((-16, 5), _components(F(u" -3.2 "))) - self.assertEquals((-3, 1), _components(F(u" -3. "))) - self.assertEquals((3, 5), _components(F(u" .6 "))) - self.assertEquals((1, 3125), _components(F("32.e-5"))) - self.assertEquals((1000000, 1), _components(F("1E+06"))) - self.assertEquals((-12300, 1), _components(F("-1.23e4"))) - self.assertEquals((0, 1), _components(F(" .0e+0\t"))) - self.assertEquals((0, 1), _components(F("-0.000e0"))) + self.assertEqual((5, 1), _components(F("5"))) + self.assertEqual((3, 2), _components(F("3/2"))) + self.assertEqual((3, 2), _components(F(" \n +3/2"))) + self.assertEqual((-3, 2), _components(F("-3/2 "))) + self.assertEqual((13, 2), _components(F(" 013/02 \n "))) + self.assertEqual((13, 2), _components(F(u" 013/02 \n "))) + + self.assertEqual((16, 5), _components(F(" 3.2 "))) + self.assertEqual((-16, 5), _components(F(u" -3.2 "))) + self.assertEqual((-3, 1), _components(F(u" -3. "))) + self.assertEqual((3, 5), _components(F(u" .6 "))) + self.assertEqual((1, 3125), _components(F("32.e-5"))) + self.assertEqual((1000000, 1), _components(F("1E+06"))) + self.assertEqual((-12300, 1), _components(F("-1.23e4"))) + self.assertEqual((0, 1), _components(F(" .0e+0\t"))) + self.assertEqual((0, 1), _components(F("-0.000e0"))) self.assertRaisesMessage( @@ -229,33 +229,33 @@ class FractionTest(unittest.TestCase): def testImmutable(self): r = F(7, 3) r.__init__(2, 15) - self.assertEquals((7, 3), _components(r)) + self.assertEqual((7, 3), _components(r)) self.assertRaises(AttributeError, setattr, r, 'numerator', 12) self.assertRaises(AttributeError, setattr, r, 'denominator', 6) - self.assertEquals((7, 3), _components(r)) + self.assertEqual((7, 3), _components(r)) # But if you _really_ need to: r._numerator = 4 r._denominator = 2 - self.assertEquals((4, 2), _components(r)) + self.assertEqual((4, 2), _components(r)) # Which breaks some important operations: - self.assertNotEquals(F(4, 2), r) + self.assertNotEqual(F(4, 2), r) def testFromFloat(self): self.assertRaises(TypeError, F.from_float, 3+4j) - self.assertEquals((10, 1), _components(F.from_float(10))) + self.assertEqual((10, 1), _components(F.from_float(10))) bigint = 1234567890123456789 - self.assertEquals((bigint, 1), _components(F.from_float(bigint))) - self.assertEquals((0, 1), _components(F.from_float(-0.0))) - self.assertEquals((10, 1), _components(F.from_float(10.0))) - self.assertEquals((-5, 2), _components(F.from_float(-2.5))) - self.assertEquals((99999999999999991611392, 1), - _components(F.from_float(1e23))) - self.assertEquals(float(10**23), float(F.from_float(1e23))) - self.assertEquals((3602879701896397, 1125899906842624), - _components(F.from_float(3.2))) - self.assertEquals(3.2, float(F.from_float(3.2))) + self.assertEqual((bigint, 1), _components(F.from_float(bigint))) + self.assertEqual((0, 1), _components(F.from_float(-0.0))) + self.assertEqual((10, 1), _components(F.from_float(10.0))) + self.assertEqual((-5, 2), _components(F.from_float(-2.5))) + self.assertEqual((99999999999999991611392, 1), + _components(F.from_float(1e23))) + self.assertEqual(float(10**23), float(F.from_float(1e23))) + self.assertEqual((3602879701896397, 1125899906842624), + _components(F.from_float(3.2))) + self.assertEqual(3.2, float(F.from_float(3.2))) inf = 1e1000 nan = inf - inf @@ -271,13 +271,13 @@ class FractionTest(unittest.TestCase): def testFromDecimal(self): self.assertRaises(TypeError, F.from_decimal, 3+4j) - self.assertEquals(F(10, 1), F.from_decimal(10)) - self.assertEquals(F(0), F.from_decimal(Decimal("-0"))) - self.assertEquals(F(5, 10), F.from_decimal(Decimal("0.5"))) - self.assertEquals(F(5, 1000), F.from_decimal(Decimal("5e-3"))) - self.assertEquals(F(5000), F.from_decimal(Decimal("5e3"))) - self.assertEquals(1 - F(1, 10**30), - F.from_decimal(Decimal("0." + "9" * 30))) + self.assertEqual(F(10, 1), F.from_decimal(10)) + self.assertEqual(F(0), F.from_decimal(Decimal("-0"))) + self.assertEqual(F(5, 10), F.from_decimal(Decimal("0.5"))) + self.assertEqual(F(5, 1000), F.from_decimal(Decimal("5e-3"))) + self.assertEqual(F(5000), F.from_decimal(Decimal("5e3"))) + self.assertEqual(1 - F(1, 10**30), + F.from_decimal(Decimal("0." + "9" * 30))) self.assertRaisesMessage( TypeError, "Cannot convert Infinity to Fraction.", @@ -306,29 +306,29 @@ class FractionTest(unittest.TestCase): self.assertTypedEquals(-1, math.trunc(F(-11, 10))) self.assertTypedEquals(-1, int(F(-11, 10))) - self.assertEquals(False, bool(F(0, 1))) - self.assertEquals(True, bool(F(3, 2))) + self.assertEqual(False, bool(F(0, 1))) + self.assertEqual(True, bool(F(3, 2))) self.assertTypedEquals(0.1, float(F(1, 10))) # Check that __float__ isn't implemented by converting the # numerator and denominator to float before dividing. self.assertRaises(OverflowError, float, long('2'*400+'7')) - self.assertAlmostEquals(2.0/3, + self.assertAlmostEqual(2.0/3, float(F(long('2'*400+'7'), long('3'*400+'1')))) self.assertTypedEquals(0.1+0j, complex(F(1,10))) def testArithmetic(self): - self.assertEquals(F(1, 2), F(1, 10) + F(2, 5)) - self.assertEquals(F(-3, 10), F(1, 10) - F(2, 5)) - self.assertEquals(F(1, 25), F(1, 10) * F(2, 5)) - self.assertEquals(F(1, 4), F(1, 10) / F(2, 5)) + self.assertEqual(F(1, 2), F(1, 10) + F(2, 5)) + self.assertEqual(F(-3, 10), F(1, 10) - F(2, 5)) + self.assertEqual(F(1, 25), F(1, 10) * F(2, 5)) + self.assertEqual(F(1, 4), F(1, 10) / F(2, 5)) self.assertTypedEquals(2, F(9, 10) // F(2, 5)) self.assertTypedEquals(10**23, F(10**23, 1) // F(1)) - self.assertEquals(F(2, 3), F(-7, 3) % F(3, 2)) - self.assertEquals(F(8, 27), F(2, 3) ** F(3)) - self.assertEquals(F(27, 8), F(2, 3) ** F(-3)) + self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2)) + self.assertEqual(F(8, 27), F(2, 3) ** F(3)) + self.assertEqual(F(27, 8), F(2, 3) ** F(-3)) self.assertTypedEquals(2.0, F(4) ** F(1, 2)) # Will return 1j in 3.0: self.assertRaises(ValueError, pow, F(-1), F(1, 2)) @@ -394,7 +394,7 @@ class FractionTest(unittest.TestCase): TypeError, "unsupported operand type(s) for +: 'Fraction' and 'Decimal'", operator.add, F(3,11), Decimal('3.1415926')) - self.assertNotEquals(F(5, 2), Decimal('2.5')) + self.assertNotEqual(F(5, 2), Decimal('2.5')) def testComparisons(self): self.assertTrue(F(1, 2) < F(2, 3)) @@ -529,18 +529,18 @@ class FractionTest(unittest.TestCase): self.assertFalse(float('-inf') == F(2, 5)) def testStringification(self): - self.assertEquals("Fraction(7, 3)", repr(F(7, 3))) - self.assertEquals("Fraction(6283185307, 2000000000)", - repr(F('3.1415926535'))) - self.assertEquals("Fraction(-1, 100000000000000000000)", - repr(F(1, -10**20))) - self.assertEquals("7/3", str(F(7, 3))) - self.assertEquals("7", str(F(7, 1))) + self.assertEqual("Fraction(7, 3)", repr(F(7, 3))) + self.assertEqual("Fraction(6283185307, 2000000000)", + repr(F('3.1415926535'))) + self.assertEqual("Fraction(-1, 100000000000000000000)", + repr(F(1, -10**20))) + self.assertEqual("7/3", str(F(7, 3))) + self.assertEqual("7", str(F(7, 1))) def testHash(self): - self.assertEquals(hash(2.5), hash(F(5, 2))) - self.assertEquals(hash(10**50), hash(F(10**50))) - self.assertNotEquals(hash(float(10**23)), hash(F(10**23))) + self.assertEqual(hash(2.5), hash(F(5, 2))) + self.assertEqual(hash(10**50), hash(F(10**50))) + self.assertNotEqual(hash(float(10**23)), hash(F(10**23))) def testApproximatePi(self): # Algorithm borrowed from @@ -553,7 +553,7 @@ class FractionTest(unittest.TestCase): d, da = d+da, da+32 t = (t * n) / d s += t - self.assertAlmostEquals(math.pi, s) + self.assertAlmostEqual(math.pi, s) def testApproximateCos1(self): # Algorithm borrowed from @@ -567,7 +567,7 @@ class FractionTest(unittest.TestCase): num *= x * x sign *= -1 s += num / fact * sign - self.assertAlmostEquals(math.cos(1), s) + self.assertAlmostEqual(math.cos(1), s) def test_copy_deepcopy_pickle(self): r = F(13, 7) diff --git a/Lib/test/test_frozen.py b/Lib/test/test_frozen.py index 7fb53a4..771f599 100644 --- a/Lib/test/test_frozen.py +++ b/Lib/test/test_frozen.py @@ -30,8 +30,8 @@ class FrozenTests(unittest.TestCase): else: self.fail("import __phello__.foo should have failed") - self.assertEquals(stdout.getvalue(), - 'Hello world...\nHello world...\nHello world...\n') + self.assertEqual(stdout.getvalue(), + 'Hello world...\nHello world...\nHello world...\n') del sys.modules['__hello__'] del sys.modules['__phello__'] diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py index c5beba1..6bc7b2b 100644 --- a/Lib/test/test_functools.py +++ b/Lib/test/test_functools.py @@ -361,12 +361,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __lt__(self, other): return self.value < other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_le(self): @functools.total_ordering @@ -375,12 +375,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __le__(self, other): return self.value <= other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_gt(self): @functools.total_ordering @@ -389,12 +389,12 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __gt__(self, other): return self.value > other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_ge(self): @functools.total_ordering @@ -403,24 +403,24 @@ class TestTotalOrdering(unittest.TestCase): self.value = value def __ge__(self, other): return self.value >= other.value - self.assert_(A(1) < A(2)) - self.assert_(A(2) > A(1)) - self.assert_(A(1) <= A(2)) - self.assert_(A(2) >= A(1)) - self.assert_(A(2) <= A(2)) - self.assert_(A(2) >= A(2)) + self.assertTrue(A(1) < A(2)) + self.assertTrue(A(2) > A(1)) + self.assertTrue(A(1) <= A(2)) + self.assertTrue(A(2) >= A(1)) + self.assertTrue(A(2) <= A(2)) + self.assertTrue(A(2) >= A(2)) def test_total_ordering_no_overwrite(self): # new methods should not overwrite existing @functools.total_ordering class A(str): pass - self.assert_(A("a") < A("b")) - self.assert_(A("b") > A("a")) - self.assert_(A("a") <= A("b")) - self.assert_(A("b") >= A("a")) - self.assert_(A("b") <= A("b")) - self.assert_(A("b") >= A("b")) + self.assertTrue(A("a") < A("b")) + self.assertTrue(A("b") > A("a")) + self.assertTrue(A("a") <= A("b")) + self.assertTrue(A("b") >= A("a")) + self.assertTrue(A("b") <= A("b")) + self.assertTrue(A("b") >= A("b")) def test_no_operations_defined(self): with self.assertRaises(ValueError): diff --git a/Lib/test/test_gdb.py b/Lib/test/test_gdb.py index 3ade185..e033dcf 100644 --- a/Lib/test/test_gdb.py +++ b/Lib/test/test_gdb.py @@ -127,7 +127,7 @@ class DebuggerTests(unittest.TestCase): '') # Ensure no unexpected error messages: - self.assertEquals(err, '') + self.assertEqual(err, '') return out @@ -155,13 +155,12 @@ class DebuggerTests(unittest.TestCase): def assertEndsWith(self, actual, exp_end): '''Ensure that the given "actual" string ends with "exp_end"''' - self.assert_(actual.endswith(exp_end), - msg='%r did not end with %r' % (actual, exp_end)) + self.assertTrue(actual.endswith(exp_end), + msg='%r did not end with %r' % (actual, exp_end)) def assertMultilineMatches(self, actual, pattern): m = re.match(pattern, actual, re.DOTALL) - self.assert_(m, - msg='%r did not match %r' % (actual, pattern)) + self.assertTrue(m, msg='%r did not match %r' % (actual, pattern)) def get_sample_script(self): return findfile('gdb_sample.py') @@ -176,7 +175,7 @@ class PrettyPrintTests(DebuggerTests): # matches repr(value) in this process: gdb_repr, gdb_output = self.get_gdb_repr('print ' + repr(val), cmds_after_breakpoint) - self.assertEquals(gdb_repr, repr(val), gdb_output) + self.assertEqual(gdb_repr, repr(val), gdb_output) def test_int(self): 'Verify the pretty-printing of various "int" values' @@ -258,7 +257,7 @@ class PrettyPrintTests(DebuggerTests): gdb_repr, gdb_output = self.get_gdb_repr('''s = set(['a','b']) s.pop() print s''') - self.assertEquals(gdb_repr, "set(['b'])") + self.assertEqual(gdb_repr, "set(['b'])") def test_frozensets(self): 'Verify the pretty-printing of frozensets' @@ -274,8 +273,8 @@ try: except RuntimeError, e: print e ''') - self.assertEquals(gdb_repr, - "exceptions.RuntimeError('I am an error',)") + self.assertEqual(gdb_repr, + "exceptions.RuntimeError('I am an error',)") # Test division by zero: @@ -285,8 +284,8 @@ try: except ZeroDivisionError, e: print e ''') - self.assertEquals(gdb_repr, - "exceptions.ZeroDivisionError('integer division or modulo by zero',)") + self.assertEqual(gdb_repr, + "exceptions.ZeroDivisionError('integer division or modulo by zero',)") def test_classic_class(self): 'Verify the pretty-printing of classic class instances' @@ -380,7 +379,7 @@ print foo''') 'backtrace']) ) - self.assertEquals(gdb_repr, '0x0') + self.assertEqual(gdb_repr, '0x0') def test_NULL_ob_type(self): 'Ensure that a PyObject* with NULL ob_type is handled gracefully' @@ -432,12 +431,12 @@ print foo''', gdb_repr, gdb_output = \ self.get_gdb_repr("a = [3, 4, 5] ; a.append(a) ; print a") - self.assertEquals(gdb_repr, '[3, 4, 5, [...]]') + self.assertEqual(gdb_repr, '[3, 4, 5, [...]]') gdb_repr, gdb_output = \ self.get_gdb_repr("a = [3, 4, 5] ; b = [a] ; a.append(b) ; print a") - self.assertEquals(gdb_repr, '[3, 4, 5, [[...]]]') + self.assertEqual(gdb_repr, '[3, 4, 5, [[...]]]') def test_selfreferential_dict(self): '''Ensure that a reference loop involving a dict doesn't lead proxyval @@ -445,7 +444,7 @@ print foo''', gdb_repr, gdb_output = \ self.get_gdb_repr("a = {} ; b = {'bar':a} ; a['foo'] = b ; print a") - self.assertEquals(gdb_repr, "{'foo': {'bar': {...}}}") + self.assertEqual(gdb_repr, "{'foo': {'bar': {...}}}") def test_selfreferential_old_style_instance(self): gdb_repr, gdb_output = \ @@ -490,34 +489,34 @@ print a''') def test_truncation(self): 'Verify that very long output is truncated' gdb_repr, gdb_output = self.get_gdb_repr('print range(1000)') - self.assertEquals(gdb_repr, - "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " - "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " - "27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " - "40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " - "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " - "66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " - "79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " - "92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " - "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " - "114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " - "124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " - "134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " - "144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " - "154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " - "164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " - "174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " - "184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " - "194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " - "204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " - "214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " - "224, 225, 226...(truncated)") - self.assertEquals(len(gdb_repr), - 1024 + len('...(truncated)')) + self.assertEqual(gdb_repr, + "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, " + "14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, " + "27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, " + "40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, " + "53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, " + "66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, " + "79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, " + "92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, " + "104, 105, 106, 107, 108, 109, 110, 111, 112, 113, " + "114, 115, 116, 117, 118, 119, 120, 121, 122, 123, " + "124, 125, 126, 127, 128, 129, 130, 131, 132, 133, " + "134, 135, 136, 137, 138, 139, 140, 141, 142, 143, " + "144, 145, 146, 147, 148, 149, 150, 151, 152, 153, " + "154, 155, 156, 157, 158, 159, 160, 161, 162, 163, " + "164, 165, 166, 167, 168, 169, 170, 171, 172, 173, " + "174, 175, 176, 177, 178, 179, 180, 181, 182, 183, " + "184, 185, 186, 187, 188, 189, 190, 191, 192, 193, " + "194, 195, 196, 197, 198, 199, 200, 201, 202, 203, " + "204, 205, 206, 207, 208, 209, 210, 211, 212, 213, " + "214, 215, 216, 217, 218, 219, 220, 221, 222, 223, " + "224, 225, 226...(truncated)") + self.assertEqual(len(gdb_repr), + 1024 + len('...(truncated)')) def test_builtin_function(self): gdb_repr, gdb_output = self.get_gdb_repr('print len') - self.assertEquals(gdb_repr, '') + self.assertEqual(gdb_repr, '') def test_builtin_method(self): gdb_repr, gdb_output = self.get_gdb_repr('import sys; print sys.stdout.readlines') diff --git a/Lib/test/test_getargs2.py b/Lib/test/test_getargs2.py index 423217b..d06296b 100644 --- a/Lib/test/test_getargs2.py +++ b/Lib/test/test_getargs2.py @@ -262,7 +262,7 @@ class Tuple_TestCase(unittest.TestCase): from _testcapi import getargs_tuple ret = getargs_tuple(1, (2, 3)) - self.assertEquals(ret, (1,2,3)) + self.assertEqual(ret, (1,2,3)) # make sure invalid tuple arguments are handled correctly class seq: @@ -275,25 +275,25 @@ class Tuple_TestCase(unittest.TestCase): class Keywords_TestCase(unittest.TestCase): def test_positional_args(self): # using all positional args - self.assertEquals( + self.assertEqual( getargs_keywords((1,2), 3, (4,(5,6)), (7,8,9), 10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ) def test_mixed_args(self): # positional and keyword args - self.assertEquals( + self.assertEqual( getargs_keywords((1,2), 3, (4,(5,6)), arg4=(7,8,9), arg5=10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ) def test_keyword_args(self): # all keywords - self.assertEquals( + self.assertEqual( getargs_keywords(arg1=(1,2), arg2=3, arg3=(4,(5,6)), arg4=(7,8,9), arg5=10), (1, 2, 3, 4, 5, 6, 7, 8, 9, 10) ) def test_optional_args(self): # missing optional keyword args, skipping tuples - self.assertEquals( + self.assertEqual( getargs_keywords(arg1=(1,2), arg2=3, arg5=10), (1, 2, 3, -1, -1, -1, -1, -1, -1, 10) ) @@ -302,14 +302,14 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords(arg1=(1,2)) except TypeError, err: - self.assertEquals(str(err), "Required argument 'arg2' (pos 2) not found") + self.assertEqual(str(err), "Required argument 'arg2' (pos 2) not found") else: self.fail('TypeError should have been raised') def test_too_many_args(self): try: getargs_keywords((1,2),3,(4,(5,6)),(7,8,9),10,111) except TypeError, err: - self.assertEquals(str(err), "function takes at most 5 arguments (6 given)") + self.assertEqual(str(err), "function takes at most 5 arguments (6 given)") else: self.fail('TypeError should have been raised') def test_invalid_keyword(self): @@ -317,7 +317,7 @@ class Keywords_TestCase(unittest.TestCase): try: getargs_keywords((1,2),3,arg5=10,arg666=666) except TypeError, err: - self.assertEquals(str(err), "'arg666' is an invalid keyword argument for this function") + self.assertEqual(str(err), "'arg666' is an invalid keyword argument for this function") else: self.fail('TypeError should have been raised') diff --git a/Lib/test/test_getopt.py b/Lib/test/test_getopt.py index 7186c7f..f924287 100644 --- a/Lib/test/test_getopt.py +++ b/Lib/test/test_getopt.py @@ -175,9 +175,9 @@ class GetoptTests(unittest.TestCase): def test_issue4629(self): longopts, shortopts = getopt.getopt(['--help='], '', ['help=']) - self.assertEquals(longopts, [('--help', '')]) + self.assertEqual(longopts, [('--help', '')]) longopts, shortopts = getopt.getopt(['--help=x'], '', ['help=']) - self.assertEquals(longopts, [('--help', 'x')]) + self.assertEqual(longopts, [('--help', 'x')]) self.assertRaises(getopt.GetoptError, getopt.getopt, ['--help='], '', ['help']) def test_main(): diff --git a/Lib/test/test_glob.py b/Lib/test/test_glob.py index 1ad59e8..692322d 100644 --- a/Lib/test/test_glob.py +++ b/Lib/test/test_glob.py @@ -59,8 +59,8 @@ class GlobTests(unittest.TestCase): if set(type(x) for x in tmp) == uniset: u1 = glob.glob(u'*') u2 = glob.glob(u'./*') - self.assertEquals(set(type(r) for r in u1), uniset) - self.assertEquals(set(type(r) for r in u2), uniset) + self.assertEqual(set(type(r) for r in u1), uniset) + self.assertEqual(set(type(r) for r in u2), uniset) def test_glob_one_directory(self): eq = self.assertSequencesEqual_noorder diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py index baa38d4..573879e 100644 --- a/Lib/test/test_gzip.py +++ b/Lib/test/test_gzip.py @@ -102,7 +102,7 @@ class TestGzip(unittest.TestCase): ztxt = zgfile.read(8192) contents += ztxt if not ztxt: break - self.assertEquals(contents, 'a'*201) + self.assertEqual(contents, 'a'*201) def test_buffered_reader(self): # Issue #7471: a GzipFile can be wrapped in a BufferedReader for @@ -166,7 +166,7 @@ class TestGzip(unittest.TestCase): f.read(10) f.seek(10, whence=1) y = f.read(10) - self.assertEquals(y, data1[20:30]) + self.assertEqual(y, data1[20:30]) def test_seek_write(self): # Try seek, write test diff --git a/Lib/test/test_htmllib.py b/Lib/test/test_htmllib.py index e1f4334..03813b0 100644 --- a/Lib/test/test_htmllib.py +++ b/Lib/test/test_htmllib.py @@ -38,11 +38,11 @@ class HTMLParserTestCase(unittest.TestCase): """) parser.close() - self.assertEquals(parser.get_anchor_info(), - [('http://foo.org/', 'splat', ''), - ('http://www.python.org/', '', ''), - ('', 'frob', ''), - ]) + self.assertEqual(parser.get_anchor_info(), + [('http://foo.org/', 'splat', ''), + ('http://www.python.org/', '', ''), + ('', 'frob', ''), + ]) def test_decl_collection(self): # See SF patch #545300 @@ -56,10 +56,10 @@ class HTMLParserTestCase(unittest.TestCase): """) parser.close() - self.assertEquals(parser.get_decl_info(), - ["if !supportEmptyParas", - "endif" - ]) + self.assertEqual(parser.get_decl_info(), + ["if !supportEmptyParas", + "endif" + ]) def test_main(): test_support.run_unittest(HTMLParserTestCase) diff --git a/Lib/test/test_httplib.py b/Lib/test/test_httplib.py index d7b73e1..bb6d3cf 100644 --- a/Lib/test/test_httplib.py +++ b/Lib/test/test_httplib.py @@ -135,7 +135,7 @@ class BasicTest(TestCase): def test_bad_status_repr(self): exc = httplib.BadStatusLine('') - self.assertEquals(repr(exc), '''BadStatusLine("\'\'",)''') + self.assertEqual(repr(exc), '''BadStatusLine("\'\'",)''') def test_partial_reads(self): # if we have a lenght, the system knows when to close itself @@ -216,13 +216,13 @@ class BasicTest(TestCase): sock = FakeSocket(None) conn.sock = sock conn.send(expected) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = '' conn.send(array.array('c', expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) sock.data = '' conn.send(StringIO.StringIO(expected)) - self.assertEquals(expected, sock.data) + self.assertEqual(expected, sock.data) def test_chunked(self): chunked_start = ( @@ -236,7 +236,7 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = httplib.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), 'hello world') + self.assertEqual(resp.read(), 'hello world') resp.close() for x in ('', 'foo\r\n'): @@ -246,7 +246,7 @@ class BasicTest(TestCase): try: resp.read() except httplib.IncompleteRead, i: - self.assertEquals(i.partial, 'hello world') + self.assertEqual(i.partial, 'hello world') self.assertEqual(repr(i),'IncompleteRead(11 bytes read)') self.assertEqual(str(i),'IncompleteRead(11 bytes read)') else: @@ -266,9 +266,9 @@ class BasicTest(TestCase): sock = FakeSocket(chunked_start + '0\r\n') resp = httplib.HTTPResponse(sock, method="HEAD") resp.begin() - self.assertEquals(resp.read(), '') - self.assertEquals(resp.status, 200) - self.assertEquals(resp.reason, 'OK') + self.assertEqual(resp.read(), '') + self.assertEqual(resp.status, 200) + self.assertEqual(resp.reason, 'OK') self.assertTrue(resp.isclosed()) def test_negative_content_length(self): @@ -276,7 +276,7 @@ class BasicTest(TestCase): 'Content-Length: -1\r\n\r\nHello\r\n') resp = httplib.HTTPResponse(sock, method="GET") resp.begin() - self.assertEquals(resp.read(), 'Hello\r\n') + self.assertEqual(resp.read(), 'Hello\r\n') resp.close() def test_incomplete_read(self): @@ -286,7 +286,7 @@ class BasicTest(TestCase): try: resp.read() except httplib.IncompleteRead as i: - self.assertEquals(i.partial, 'Hello\r\n') + self.assertEqual(i.partial, 'Hello\r\n') self.assertEqual(repr(i), "IncompleteRead(7 bytes read, 3 more expected)") self.assertEqual(str(i), @@ -321,7 +321,7 @@ class BasicTest(TestCase): class OfflineTest(TestCase): def test_responses(self): - self.assertEquals(httplib.responses[httplib.NOT_FOUND], "Not Found") + self.assertEqual(httplib.responses[httplib.NOT_FOUND], "Not Found") class SourceAddressTest(TestCase): diff --git a/Lib/test/test_imaplib.py b/Lib/test/test_imaplib.py index 00db29d..15b0ea0 100644 --- a/Lib/test/test_imaplib.py +++ b/Lib/test/test_imaplib.py @@ -112,7 +112,7 @@ class BaseThreadedNetworkedTests(unittest.TestCase): if verbose: print "creating server" server = MyServer(addr, hdlr) - self.assertEquals(server.server_address, server.socket.getsockname()) + self.assertEqual(server.server_address, server.socket.getsockname()) if verbose: print "server created" diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py index 08630a5..fcdfd94 100644 --- a/Lib/test/test_inspect.py +++ b/Lib/test/test_inspect.py @@ -384,8 +384,8 @@ class TestBuggyCases(GetSourceBase): self.assertRaises(IOError, inspect.findsource, co) self.assertRaises(IOError, inspect.getsource, co) linecache.cache[co.co_filename] = (1, None, lines, co.co_filename) - self.assertEquals(inspect.findsource(co), (lines,0)) - self.assertEquals(inspect.getsource(co), lines[0]) + self.assertEqual(inspect.findsource(co), (lines,0)) + self.assertEqual(inspect.getsource(co), lines[0]) # Helper for testing classify_class_attrs. def attrs_wo_objs(cls): diff --git a/Lib/test/test_int.py b/Lib/test/test_int.py index 6e611c2..fa46212 100644 --- a/Lib/test/test_int.py +++ b/Lib/test/test_int.py @@ -392,7 +392,7 @@ class IntTestCases(unittest.TestCase): try: int(TruncReturnsNonIntegral()) except TypeError as e: - self.assertEquals(str(e), + self.assertEqual(str(e), "__trunc__ returned non-Integral" " (type NonIntegral)") else: diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py index 2b4a3a9..ad2919b 100644 --- a/Lib/test/test_io.py +++ b/Lib/test/test_io.py @@ -606,7 +606,7 @@ class CommonBufferedTests: rawio = self.MockRawIO() bufio = self.tp(rawio) - self.assertEquals(42, bufio.fileno()) + self.assertEqual(42, bufio.fileno()) def test_no_fileno(self): # XXX will we always have fileno() function? If so, kill @@ -711,36 +711,36 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): bufio.__init__(rawio) bufio.__init__(rawio, buffer_size=1024) bufio.__init__(rawio, buffer_size=16) - self.assertEquals(b"abc", bufio.read()) + self.assertEqual(b"abc", bufio.read()) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) rawio = self.MockRawIO([b"abc"]) bufio.__init__(rawio) - self.assertEquals(b"abc", bufio.read()) + self.assertEqual(b"abc", bufio.read()) def test_read(self): for arg in (None, 7): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"abcdefg", bufio.read(arg)) + self.assertEqual(b"abcdefg", bufio.read(arg)) # Invalid args self.assertRaises(ValueError, bufio.read, -2) def test_read1(self): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"a", bufio.read(1)) - self.assertEquals(b"b", bufio.read1(1)) - self.assertEquals(rawio._reads, 1) - self.assertEquals(b"c", bufio.read1(100)) - self.assertEquals(rawio._reads, 1) - self.assertEquals(b"d", bufio.read1(100)) - self.assertEquals(rawio._reads, 2) - self.assertEquals(b"efg", bufio.read1(100)) - self.assertEquals(rawio._reads, 3) - self.assertEquals(b"", bufio.read1(100)) - self.assertEquals(rawio._reads, 4) + self.assertEqual(b"a", bufio.read(1)) + self.assertEqual(b"b", bufio.read1(1)) + self.assertEqual(rawio._reads, 1) + self.assertEqual(b"c", bufio.read1(100)) + self.assertEqual(rawio._reads, 1) + self.assertEqual(b"d", bufio.read1(100)) + self.assertEqual(rawio._reads, 2) + self.assertEqual(b"efg", bufio.read1(100)) + self.assertEqual(rawio._reads, 3) + self.assertEqual(b"", bufio.read1(100)) + self.assertEqual(rawio._reads, 4) # Invalid args self.assertRaises(ValueError, bufio.read1, -1) @@ -748,24 +748,24 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) b = bytearray(2) - self.assertEquals(bufio.readinto(b), 2) - self.assertEquals(b, b"ab") - self.assertEquals(bufio.readinto(b), 2) - self.assertEquals(b, b"cd") - self.assertEquals(bufio.readinto(b), 2) - self.assertEquals(b, b"ef") - self.assertEquals(bufio.readinto(b), 1) - self.assertEquals(b, b"gf") - self.assertEquals(bufio.readinto(b), 0) - self.assertEquals(b, b"gf") + self.assertEqual(bufio.readinto(b), 2) + self.assertEqual(b, b"ab") + self.assertEqual(bufio.readinto(b), 2) + self.assertEqual(b, b"cd") + self.assertEqual(bufio.readinto(b), 2) + self.assertEqual(b, b"ef") + self.assertEqual(bufio.readinto(b), 1) + self.assertEqual(b, b"gf") + self.assertEqual(bufio.readinto(b), 0) + self.assertEqual(b, b"gf") def test_readlines(self): def bufio(): rawio = self.MockRawIO((b"abc\n", b"d\n", b"ef")) return self.tp(rawio) - self.assertEquals(bufio().readlines(), [b"abc\n", b"d\n", b"ef"]) - self.assertEquals(bufio().readlines(5), [b"abc\n", b"d\n"]) - self.assertEquals(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"]) + self.assertEqual(bufio().readlines(), [b"abc\n", b"d\n", b"ef"]) + self.assertEqual(bufio().readlines(5), [b"abc\n", b"d\n"]) + self.assertEqual(bufio().readlines(None), [b"abc\n", b"d\n", b"ef"]) def test_buffering(self): data = b"abcdefghi" @@ -782,34 +782,34 @@ class BufferedReaderTest(unittest.TestCase, CommonBufferedTests): bufio = self.tp(rawio, buffer_size=bufsize) pos = 0 for nbytes in buf_read_sizes: - self.assertEquals(bufio.read(nbytes), data[pos:pos+nbytes]) + self.assertEqual(bufio.read(nbytes), data[pos:pos+nbytes]) pos += nbytes # this is mildly implementation-dependent - self.assertEquals(rawio.read_history, raw_read_sizes) + self.assertEqual(rawio.read_history, raw_read_sizes) def test_read_non_blocking(self): # Inject some None's in there to simulate EWOULDBLOCK rawio = self.MockRawIO((b"abc", b"d", None, b"efg", None, None, None)) bufio = self.tp(rawio) - self.assertEquals(b"abcd", bufio.read(6)) - self.assertEquals(b"e", bufio.read(1)) - self.assertEquals(b"fg", bufio.read()) - self.assertEquals(b"", bufio.peek(1)) + self.assertEqual(b"abcd", bufio.read(6)) + self.assertEqual(b"e", bufio.read(1)) + self.assertEqual(b"fg", bufio.read()) + self.assertEqual(b"", bufio.peek(1)) self.assertTrue(None is bufio.read()) - self.assertEquals(b"", bufio.read()) + self.assertEqual(b"", bufio.read()) def test_read_past_eof(self): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"abcdefg", bufio.read(9000)) + self.assertEqual(b"abcdefg", bufio.read(9000)) def test_read_all(self): rawio = self.MockRawIO((b"abc", b"d", b"efg")) bufio = self.tp(rawio) - self.assertEquals(b"abcdefg", bufio.read()) + self.assertEqual(b"abcdefg", bufio.read()) @unittest.skipUnless(threading, 'Threading required for this test.') @support.requires_resource('cpu') @@ -936,15 +936,15 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): bufio.__init__(rawio) bufio.__init__(rawio, buffer_size=1024) bufio.__init__(rawio, buffer_size=16) - self.assertEquals(3, bufio.write(b"abc")) + self.assertEqual(3, bufio.write(b"abc")) bufio.flush() self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=0) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-16) self.assertRaises(ValueError, bufio.__init__, rawio, buffer_size=-1) bufio.__init__(rawio) - self.assertEquals(3, bufio.write(b"ghi")) + self.assertEqual(3, bufio.write(b"ghi")) bufio.flush() - self.assertEquals(b"".join(rawio._write_stack), b"abcghi") + self.assertEqual(b"".join(rawio._write_stack), b"abcghi") def test_detach_flush(self): raw = self.MockRawIO() @@ -986,11 +986,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): sizes = gen_sizes() while n < len(contents): size = min(next(sizes), len(contents) - n) - self.assertEquals(bufio.write(contents[n:n+size]), size) + self.assertEqual(bufio.write(contents[n:n+size]), size) intermediate_func(bufio) n += size bufio.flush() - self.assertEquals(contents, + self.assertEqual(contents, b"".join(writer._write_stack)) def test_writes(self): @@ -1020,11 +1020,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): raw = self.MockNonBlockWriterIO() bufio = self.tp(raw, 8) - self.assertEquals(bufio.write(b"abcd"), 4) - self.assertEquals(bufio.write(b"efghi"), 5) + self.assertEqual(bufio.write(b"abcd"), 4) + self.assertEqual(bufio.write(b"efghi"), 5) # 1 byte will be written, the rest will be buffered raw.block_on(b"k") - self.assertEquals(bufio.write(b"jklmn"), 5) + self.assertEqual(bufio.write(b"jklmn"), 5) # 8 bytes will be written, 8 will be buffered and the rest will be lost raw.block_on(b"0") @@ -1034,11 +1034,11 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): written = e.characters_written else: self.fail("BlockingIOError should have been raised") - self.assertEquals(written, 16) - self.assertEquals(raw.pop_written(), + self.assertEqual(written, 16) + self.assertEqual(raw.pop_written(), b"abcdefghijklmnopqrwxyz") - self.assertEquals(bufio.write(b"ABCDEFGHI"), 9) + self.assertEqual(bufio.write(b"ABCDEFGHI"), 9) s = raw.pop_written() # Previously buffered bytes were flushed self.assertTrue(s.startswith(b"01234567A"), s) @@ -1061,7 +1061,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): bufio = self.tp(writer, 8) bufio.write(b"abc") bufio.flush() - self.assertEquals(b"abc", writer._write_stack[0]) + self.assertEqual(b"abc", writer._write_stack[0]) def test_destructor(self): writer = self.MockRawIO() @@ -1069,7 +1069,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): bufio.write(b"abc") del bufio support.gc_collect() - self.assertEquals(b"abc", writer._write_stack[0]) + self.assertEqual(b"abc", writer._write_stack[0]) def test_truncate(self): # Truncate implicitly flushes the buffer. @@ -1128,7 +1128,7 @@ class BufferedWriterTest(unittest.TestCase, CommonBufferedTests): with self.open(support.TESTFN, "rb") as f: s = f.read() for i in range(256): - self.assertEquals(s.count(bytes([i])), N) + self.assertEqual(s.count(bytes([i])), N) finally: support.unlink(support.TESTFN) @@ -1329,45 +1329,45 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): rw.write(b"eee") self.assertFalse(raw._write_stack) # Buffer writes self.assertEqual(b"ghjk", rw.read()) - self.assertEquals(b"dddeee", raw._write_stack[0]) + self.assertEqual(b"dddeee", raw._write_stack[0]) def test_seek_and_tell(self): raw = self.BytesIO(b"asdfghjkl") rw = self.tp(raw) - self.assertEquals(b"as", rw.read(2)) - self.assertEquals(2, rw.tell()) + self.assertEqual(b"as", rw.read(2)) + self.assertEqual(2, rw.tell()) rw.seek(0, 0) - self.assertEquals(b"asdf", rw.read(4)) + self.assertEqual(b"asdf", rw.read(4)) rw.write(b"asdf") rw.seek(0, 0) - self.assertEquals(b"asdfasdfl", rw.read()) - self.assertEquals(9, rw.tell()) + self.assertEqual(b"asdfasdfl", rw.read()) + self.assertEqual(9, rw.tell()) rw.seek(-4, 2) - self.assertEquals(5, rw.tell()) + self.assertEqual(5, rw.tell()) rw.seek(2, 1) - self.assertEquals(7, rw.tell()) - self.assertEquals(b"fl", rw.read(11)) + self.assertEqual(7, rw.tell()) + self.assertEqual(b"fl", rw.read(11)) self.assertRaises(TypeError, rw.seek, 0.0) def check_flush_and_read(self, read_func): raw = self.BytesIO(b"abcdefghi") bufio = self.tp(raw) - self.assertEquals(b"ab", read_func(bufio, 2)) + self.assertEqual(b"ab", read_func(bufio, 2)) bufio.write(b"12") - self.assertEquals(b"ef", read_func(bufio, 2)) - self.assertEquals(6, bufio.tell()) + self.assertEqual(b"ef", read_func(bufio, 2)) + self.assertEqual(6, bufio.tell()) bufio.flush() - self.assertEquals(6, bufio.tell()) - self.assertEquals(b"ghi", read_func(bufio)) + self.assertEqual(6, bufio.tell()) + self.assertEqual(b"ghi", read_func(bufio)) raw.seek(0, 0) raw.write(b"XYZ") # flush() resets the read buffer bufio.flush() bufio.seek(0, 0) - self.assertEquals(b"XYZ", read_func(bufio, 3)) + self.assertEqual(b"XYZ", read_func(bufio, 3)) def test_flush_and_read(self): self.check_flush_and_read(lambda bufio, *args: bufio.read(*args)) @@ -1399,8 +1399,8 @@ class BufferedRandomTest(BufferedReaderTest, BufferedWriterTest): bufio.write(b"45") bufio.flush() bufio.seek(0, 0) - self.assertEquals(b"12345fghi", raw.getvalue()) - self.assertEquals(b"12345fghi", bufio.read()) + self.assertEqual(b"12345fghi", raw.getvalue()) + self.assertEqual(b"12345fghi", bufio.read()) def test_threads(self): BufferedReaderTest.test_threads(self) @@ -1625,12 +1625,12 @@ class StatefulIncrementalDecoderTest(unittest.TestCase): # Try a few one-shot test cases. for input, eof, output in self.test_cases: d = StatefulIncrementalDecoder() - self.assertEquals(d.decode(input, eof), output) + self.assertEqual(d.decode(input, eof), output) # Also test an unfinished decode, followed by forcing EOF. d = StatefulIncrementalDecoder() - self.assertEquals(d.decode(b'oiabcd'), '') - self.assertEquals(d.decode(b'', 1), 'abcd.') + self.assertEqual(d.decode(b'oiabcd'), '') + self.assertEqual(d.decode(b'', 1), 'abcd.') class TextIOWrapperTest(unittest.TestCase): @@ -1647,12 +1647,12 @@ class TextIOWrapperTest(unittest.TestCase): b = self.BufferedReader(r, 1000) t = self.TextIOWrapper(b) t.__init__(b, encoding="latin1", newline="\r\n") - self.assertEquals(t.encoding, "latin1") - self.assertEquals(t.line_buffering, False) + self.assertEqual(t.encoding, "latin1") + self.assertEqual(t.line_buffering, False) t.__init__(b, encoding="utf8", line_buffering=True) - self.assertEquals(t.encoding, "utf8") - self.assertEquals(t.line_buffering, True) - self.assertEquals("\xe9\n", t.readline()) + self.assertEqual(t.encoding, "utf8") + self.assertEqual(t.line_buffering, True) + self.assertEqual("\xe9\n", t.readline()) self.assertRaises(TypeError, t.__init__, b, newline=42) self.assertRaises(ValueError, t.__init__, b, newline='xyzzy') @@ -1688,11 +1688,11 @@ class TextIOWrapperTest(unittest.TestCase): b = self.BufferedWriter(r, 1000) t = self.TextIOWrapper(b, newline="\n", line_buffering=True) t.write("X") - self.assertEquals(r.getvalue(), b"") # No flush happened + self.assertEqual(r.getvalue(), b"") # No flush happened t.write("Y\nZ") - self.assertEquals(r.getvalue(), b"XY\nZ") # All got flushed + self.assertEqual(r.getvalue(), b"XY\nZ") # All got flushed t.write("A\rB") - self.assertEquals(r.getvalue(), b"XY\nZA\rB") + self.assertEqual(r.getvalue(), b"XY\nZA\rB") def test_encoding(self): # Check the encoding attribute is always set, and valid @@ -1715,11 +1715,11 @@ class TextIOWrapperTest(unittest.TestCase): # (3) ignore b = self.BytesIO(b"abc\n\xff\n") t = self.TextIOWrapper(b, encoding="ascii", errors="ignore") - self.assertEquals(t.read(), "abc\n\n") + self.assertEqual(t.read(), "abc\n\n") # (4) replace b = self.BytesIO(b"abc\n\xff\n") t = self.TextIOWrapper(b, encoding="ascii", errors="replace") - self.assertEquals(t.read(), "abc\n\ufffd\n") + self.assertEqual(t.read(), "abc\n\ufffd\n") def test_encoding_errors_writing(self): # (1) default @@ -1736,14 +1736,14 @@ class TextIOWrapperTest(unittest.TestCase): newline="\n") t.write("abc\xffdef\n") t.flush() - self.assertEquals(b.getvalue(), b"abcdef\n") + self.assertEqual(b.getvalue(), b"abcdef\n") # (4) replace b = self.BytesIO() t = self.TextIOWrapper(b, encoding="ascii", errors="replace", newline="\n") t.write("abc\xffdef\n") t.flush() - self.assertEquals(b.getvalue(), b"abc?def\n") + self.assertEqual(b.getvalue(), b"abc?def\n") def test_newlines(self): input_lines = [ "unix\n", "windows\r\n", "os9\r", "last\n", "nonl" ] @@ -1778,14 +1778,14 @@ class TextIOWrapperTest(unittest.TestCase): c2 = textio.read(2) if c2 == '': break - self.assertEquals(len(c2), 2) + self.assertEqual(len(c2), 2) got_lines.append(c2 + textio.readline()) else: got_lines = list(textio) for got_line, exp_line in zip(got_lines, exp_lines): - self.assertEquals(got_line, exp_line) - self.assertEquals(len(got_lines), len(exp_lines)) + self.assertEqual(got_line, exp_line) + self.assertEqual(len(got_lines), len(exp_lines)) def test_newlines_input(self): testdata = b"AAA\nBB\x00B\nCCC\rDDD\rEEE\r\nFFF\r\nGGG" @@ -1799,9 +1799,9 @@ class TextIOWrapperTest(unittest.TestCase): ]: buf = self.BytesIO(testdata) txt = self.TextIOWrapper(buf, encoding="ascii", newline=newline) - self.assertEquals(txt.readlines(), expected) + self.assertEqual(txt.readlines(), expected) txt.seek(0) - self.assertEquals(txt.read(), "".join(expected)) + self.assertEqual(txt.read(), "".join(expected)) def test_newlines_output(self): testdict = { @@ -1818,8 +1818,8 @@ class TextIOWrapperTest(unittest.TestCase): txt.write("BB\nCCC\n") txt.write("X\rY\r\nZ") txt.flush() - self.assertEquals(buf.closed, False) - self.assertEquals(buf.getvalue(), expected) + self.assertEqual(buf.closed, False) + self.assertEqual(buf.getvalue(), expected) def test_destructor(self): l = [] @@ -1833,7 +1833,7 @@ class TextIOWrapperTest(unittest.TestCase): t.write("abc") del t support.gc_collect() - self.assertEquals([b"abc"], l) + self.assertEqual([b"abc"], l) def test_override_destructor(self): record = [] @@ -1880,26 +1880,26 @@ class TextIOWrapperTest(unittest.TestCase): for enc in "ascii", "latin1", "utf8" :# , "utf-16-be", "utf-16-le": f = self.open(support.TESTFN, "w+", encoding=enc) f._CHUNK_SIZE = chunksize - self.assertEquals(f.write("abc"), 3) + self.assertEqual(f.write("abc"), 3) f.close() f = self.open(support.TESTFN, "r+", encoding=enc) f._CHUNK_SIZE = chunksize - self.assertEquals(f.tell(), 0) - self.assertEquals(f.read(), "abc") + self.assertEqual(f.tell(), 0) + self.assertEqual(f.read(), "abc") cookie = f.tell() - self.assertEquals(f.seek(0), 0) - self.assertEquals(f.read(None), "abc") + self.assertEqual(f.seek(0), 0) + self.assertEqual(f.read(None), "abc") f.seek(0) - self.assertEquals(f.read(2), "ab") - self.assertEquals(f.read(1), "c") - self.assertEquals(f.read(1), "") - self.assertEquals(f.read(), "") - self.assertEquals(f.tell(), cookie) - self.assertEquals(f.seek(0), 0) - self.assertEquals(f.seek(0, 2), cookie) - self.assertEquals(f.write("def"), 3) - self.assertEquals(f.seek(cookie), cookie) - self.assertEquals(f.read(), "def") + self.assertEqual(f.read(2), "ab") + self.assertEqual(f.read(1), "c") + self.assertEqual(f.read(1), "") + self.assertEqual(f.read(), "") + self.assertEqual(f.tell(), cookie) + self.assertEqual(f.seek(0), 0) + self.assertEqual(f.seek(0, 2), cookie) + self.assertEqual(f.write("def"), 3) + self.assertEqual(f.seek(cookie), cookie) + self.assertEqual(f.read(), "def") if enc.startswith("utf"): self.multi_line_test(f, enc) f.close() @@ -1924,7 +1924,7 @@ class TextIOWrapperTest(unittest.TestCase): if not line: break rlines.append((pos, line)) - self.assertEquals(rlines, wlines) + self.assertEqual(rlines, wlines) def test_telling(self): f = self.open(support.TESTFN, "w+", encoding="utf8") @@ -1934,16 +1934,16 @@ class TextIOWrapperTest(unittest.TestCase): f.write("\xff\n") p2 = f.tell() f.seek(0) - self.assertEquals(f.tell(), p0) - self.assertEquals(f.readline(), "\xff\n") - self.assertEquals(f.tell(), p1) - self.assertEquals(f.readline(), "\xff\n") - self.assertEquals(f.tell(), p2) + self.assertEqual(f.tell(), p0) + self.assertEqual(f.readline(), "\xff\n") + self.assertEqual(f.tell(), p1) + self.assertEqual(f.readline(), "\xff\n") + self.assertEqual(f.tell(), p2) f.seek(0) for line in f: - self.assertEquals(line, "\xff\n") + self.assertEqual(line, "\xff\n") self.assertRaises(IOError, f.tell) - self.assertEquals(f.tell(), p2) + self.assertEqual(f.tell(), p2) f.close() def test_seeking(self): @@ -1951,7 +1951,7 @@ class TextIOWrapperTest(unittest.TestCase): prefix_size = chunk_size - 2 u_prefix = "a" * prefix_size prefix = bytes(u_prefix.encode("utf-8")) - self.assertEquals(len(u_prefix), len(prefix)) + self.assertEqual(len(u_prefix), len(prefix)) u_suffix = "\u8888\n" suffix = bytes(u_suffix.encode("utf-8")) line = prefix + suffix @@ -1960,9 +1960,9 @@ class TextIOWrapperTest(unittest.TestCase): f.close() f = self.open(support.TESTFN, "r", encoding="utf-8") s = f.read(prefix_size) - self.assertEquals(s, prefix.decode("ascii")) - self.assertEquals(f.tell(), prefix_size) - self.assertEquals(f.readline(), u_suffix) + self.assertEqual(s, prefix.decode("ascii")) + self.assertEqual(f.tell(), prefix_size) + self.assertEqual(f.readline(), u_suffix) def test_seeking_too(self): # Regression test for a specific bug @@ -1995,11 +1995,11 @@ class TextIOWrapperTest(unittest.TestCase): for i in range(min_pos, len(decoded) + 1): # seek positions for j in [1, 5, len(decoded) - i]: # read lengths f = self.open(support.TESTFN, encoding='test_decoder') - self.assertEquals(f.read(i), decoded[:i]) + self.assertEqual(f.read(i), decoded[:i]) cookie = f.tell() - self.assertEquals(f.read(j), decoded[i:i + j]) + self.assertEqual(f.read(j), decoded[i:i + j]) f.seek(cookie) - self.assertEquals(f.read(), decoded[i:]) + self.assertEqual(f.read(), decoded[i:]) f.close() # Enable the test decoder. @@ -2038,10 +2038,10 @@ class TextIOWrapperTest(unittest.TestCase): f.write(data) f.write(data) f.seek(0) - self.assertEquals(f.read(), data * 2) + self.assertEqual(f.read(), data * 2) f.seek(0) - self.assertEquals(f.read(), data * 2) - self.assertEquals(buf.getvalue(), (data * 2).encode(encoding)) + self.assertEqual(f.read(), data * 2) + self.assertEqual(buf.getvalue(), (data * 2).encode(encoding)) def test_unreadable(self): class UnReadable(self.BytesIO): @@ -2058,7 +2058,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, "AA\nBB") + self.assertEqual(reads, "AA\nBB") def test_readlines(self): txt = self.TextIOWrapper(self.BytesIO(b"AA\nBB\nCC")) @@ -2078,7 +2078,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, "A"*127+"\nB") + self.assertEqual(reads, "A"*127+"\nB") def test_issue1395_1(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2090,7 +2090,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_2(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2102,7 +2102,7 @@ class TextIOWrapperTest(unittest.TestCase): if not c: break reads += c - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_3(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2113,7 +2113,7 @@ class TextIOWrapperTest(unittest.TestCase): reads += txt.readline() reads += txt.readline() reads += txt.readline() - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_4(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2121,7 +2121,7 @@ class TextIOWrapperTest(unittest.TestCase): reads = txt.read(4) reads += txt.read() - self.assertEquals(reads, self.normalized) + self.assertEqual(reads, self.normalized) def test_issue1395_5(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2131,7 +2131,7 @@ class TextIOWrapperTest(unittest.TestCase): pos = txt.tell() txt.seek(0) txt.seek(pos) - self.assertEquals(txt.read(4), "BBB\n") + self.assertEqual(txt.read(4), "BBB\n") def test_issue2282(self): buffer = self.BytesIO(self.testdata) @@ -2147,12 +2147,12 @@ class TextIOWrapperTest(unittest.TestCase): f.write('aaa') pos = f.tell() with self.open(filename, 'rb') as f: - self.assertEquals(f.read(), 'aaa'.encode(charset)) + self.assertEqual(f.read(), 'aaa'.encode(charset)) with self.open(filename, 'a', encoding=charset) as f: f.write('xxx') with self.open(filename, 'rb') as f: - self.assertEquals(f.read(), 'aaaxxx'.encode(charset)) + self.assertEqual(f.read(), 'aaaxxx'.encode(charset)) def test_seek_bom(self): # Same test, but when seeking manually @@ -2167,7 +2167,7 @@ class TextIOWrapperTest(unittest.TestCase): f.seek(0) f.write('bbb') with self.open(filename, 'rb') as f: - self.assertEquals(f.read(), 'bbbzzz'.encode(charset)) + self.assertEqual(f.read(), 'bbbzzz'.encode(charset)) def test_errors_property(self): with self.open(support.TESTFN, "w") as f: @@ -2195,7 +2195,7 @@ class TextIOWrapperTest(unittest.TestCase): with self.open(support.TESTFN) as f: content = f.read() for n in range(20): - self.assertEquals(content.count("Thread%03d\n" % n), 1) + self.assertEqual(content.count("Thread%03d\n" % n), 1) def test_flush_error_on_close(self): txt = self.TextIOWrapper(self.BytesIO(self.testdata), encoding="ascii") @@ -2249,9 +2249,9 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): def _check_decode(b, s, **kwargs): # We exercise getstate() / setstate() as well as decode() state = decoder.getstate() - self.assertEquals(decoder.decode(b, **kwargs), s) + self.assertEqual(decoder.decode(b, **kwargs), s) decoder.setstate(state) - self.assertEquals(decoder.decode(b, **kwargs), s) + self.assertEqual(decoder.decode(b, **kwargs), s) _check_decode(b'\xe8\xa2\x88', "\u8888") @@ -2300,24 +2300,24 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): # Decode one char at a time for c in s: result.append(decoder.decode(c)) - self.assertEquals(decoder.newlines, None) + self.assertEqual(decoder.newlines, None) _decode_bytewise("abc\n\r") - self.assertEquals(decoder.newlines, '\n') + self.assertEqual(decoder.newlines, '\n') _decode_bytewise("\nabc") - self.assertEquals(decoder.newlines, ('\n', '\r\n')) + self.assertEqual(decoder.newlines, ('\n', '\r\n')) _decode_bytewise("abc\r") - self.assertEquals(decoder.newlines, ('\n', '\r\n')) + self.assertEqual(decoder.newlines, ('\n', '\r\n')) _decode_bytewise("abc") - self.assertEquals(decoder.newlines, ('\r', '\n', '\r\n')) + self.assertEqual(decoder.newlines, ('\r', '\n', '\r\n')) _decode_bytewise("abc\r") - self.assertEquals("".join(result), "abc\n\nabcabc\nabcabc") + self.assertEqual("".join(result), "abc\n\nabcabc\nabcabc") decoder.reset() input = "abc" if encoder is not None: encoder.reset() input = encoder.encode(input) - self.assertEquals(decoder.decode(input), "abc") - self.assertEquals(decoder.newlines, None) + self.assertEqual(decoder.decode(input), "abc") + self.assertEqual(decoder.newlines, None) def test_newline_decoder(self): encodings = ( @@ -2338,11 +2338,11 @@ class IncrementalNewlineDecoderTest(unittest.TestCase): def test_newline_bytes(self): # Issue 5433: Excessive optimization in IncrementalNewlineDecoder def _check(dec): - self.assertEquals(dec.newlines, None) - self.assertEquals(dec.decode("\u0D00"), "\u0D00") - self.assertEquals(dec.newlines, None) - self.assertEquals(dec.decode("\u0A00"), "\u0A00") - self.assertEquals(dec.newlines, None) + self.assertEqual(dec.newlines, None) + self.assertEqual(dec.decode("\u0D00"), "\u0D00") + self.assertEqual(dec.newlines, None) + self.assertEqual(dec.decode("\u0A00"), "\u0A00") + self.assertEqual(dec.newlines, None) dec = self.IncrementalNewlineDecoder(None, translate=False) _check(dec) dec = self.IncrementalNewlineDecoder(None, translate=True) @@ -2375,28 +2375,28 @@ class MiscIOTest(unittest.TestCase): def test_attributes(self): f = self.open(support.TESTFN, "wb", buffering=0) - self.assertEquals(f.mode, "wb") + self.assertEqual(f.mode, "wb") f.close() f = self.open(support.TESTFN, "U") - self.assertEquals(f.name, support.TESTFN) - self.assertEquals(f.buffer.name, support.TESTFN) - self.assertEquals(f.buffer.raw.name, support.TESTFN) - self.assertEquals(f.mode, "U") - self.assertEquals(f.buffer.mode, "rb") - self.assertEquals(f.buffer.raw.mode, "rb") + self.assertEqual(f.name, support.TESTFN) + self.assertEqual(f.buffer.name, support.TESTFN) + self.assertEqual(f.buffer.raw.name, support.TESTFN) + self.assertEqual(f.mode, "U") + self.assertEqual(f.buffer.mode, "rb") + self.assertEqual(f.buffer.raw.mode, "rb") f.close() f = self.open(support.TESTFN, "w+") - self.assertEquals(f.mode, "w+") - self.assertEquals(f.buffer.mode, "rb+") # Does it really matter? - self.assertEquals(f.buffer.raw.mode, "rb+") + self.assertEqual(f.mode, "w+") + self.assertEqual(f.buffer.mode, "rb+") # Does it really matter? + self.assertEqual(f.buffer.raw.mode, "rb+") g = self.open(f.fileno(), "wb", closefd=False) - self.assertEquals(g.mode, "wb") - self.assertEquals(g.raw.mode, "wb") - self.assertEquals(g.name, f.fileno()) - self.assertEquals(g.raw.name, f.fileno()) + self.assertEqual(g.mode, "wb") + self.assertEqual(g.raw.mode, "wb") + self.assertEqual(g.name, f.fileno()) + self.assertEqual(g.raw.name, f.fileno()) f.close() g.close() diff --git a/Lib/test/test_ioctl.py b/Lib/test/test_ioctl.py index 48857df..ae965d8 100644 --- a/Lib/test/test_ioctl.py +++ b/Lib/test/test_ioctl.py @@ -50,7 +50,7 @@ class IoctlTests(unittest.TestCase): with open("/dev/tty", "r") as tty: r = fcntl.ioctl(tty, termios.TIOCGPGRP, buf, 1) rpgrp = buf[0] - self.assertEquals(r, 0) + self.assertEqual(r, 0) self.assertIn(rpgrp, ids) def test_ioctl_mutate(self): diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index e91ac28..2ef35d6 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -192,7 +192,7 @@ class TestBasicOps(unittest.TestCase): regular_combs = list(combinations(values, r)) # compare to combs without replacement if n == 0 or r <= 1: - self.assertEquals(result, regular_combs) # cases that should be identical + self.assertEqual(result, regular_combs) # cases that should be identical else: self.assertTrue(set(result) >= set(regular_combs)) # rest should be supersets of regular combs @@ -288,20 +288,20 @@ class TestBasicOps(unittest.TestCase): comb = list(combinations(s, r)) # Check size - self.assertEquals(len(prod), n**r) - self.assertEquals(len(cwr), (fact(n+r-1) // fact(r) // fact(n-1)) if n else (not r)) - self.assertEquals(len(perm), 0 if r>n else fact(n) // fact(n-r)) - self.assertEquals(len(comb), 0 if r>n else fact(n) // fact(r) // fact(n-r)) + self.assertEqual(len(prod), n**r) + self.assertEqual(len(cwr), (fact(n+r-1) // fact(r) // fact(n-1)) if n else (not r)) + self.assertEqual(len(perm), 0 if r>n else fact(n) // fact(n-r)) + self.assertEqual(len(comb), 0 if r>n else fact(n) // fact(r) // fact(n-r)) # Check lexicographic order without repeated tuples - self.assertEquals(prod, sorted(set(prod))) - self.assertEquals(cwr, sorted(set(cwr))) - self.assertEquals(perm, sorted(set(perm))) - self.assertEquals(comb, sorted(set(comb))) + self.assertEqual(prod, sorted(set(prod))) + self.assertEqual(cwr, sorted(set(cwr))) + self.assertEqual(perm, sorted(set(perm))) + self.assertEqual(comb, sorted(set(comb))) # Check interrelationships - self.assertEquals(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted - self.assertEquals(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups + self.assertEqual(cwr, [t for t in prod if sorted(t)==list(t)]) # cwr: prods which are sorted + self.assertEqual(perm, [t for t in prod if len(set(t))==r]) # perm: prods with no dups self.assertEqual(comb, [t for t in perm if sorted(t)==list(t)]) # comb: perms that are sorted self.assertEqual(comb, [t for t in cwr if len(set(t))==r]) # comb: cwrs without dups self.assertEqual(comb, filter(set(cwr).__contains__, perm)) # comb: perm that is a cwr diff --git a/Lib/test/test_kqueue.py b/Lib/test/test_kqueue.py index a1f3cbe..e5eecfa 100644 --- a/Lib/test/test_kqueue.py +++ b/Lib/test/test_kqueue.py @@ -90,7 +90,7 @@ class TestKQueue(unittest.TestCase): try: client.connect(('127.0.0.1', serverSocket.getsockname()[1])) except socket.error, e: - self.assertEquals(e.args[0], errno.EINPROGRESS) + self.assertEqual(e.args[0], errno.EINPROGRESS) else: #raise AssertionError("Connect should have raised EINPROGRESS") pass # FreeBSD doesn't raise an exception here @@ -124,7 +124,7 @@ class TestKQueue(unittest.TestCase): events = kq.control(None, 4, 1) events = [(e.ident, e.filter, e.flags) for e in events] events.sort() - self.assertEquals(events, [ + self.assertEqual(events, [ (client.fileno(), select.KQ_FILTER_WRITE, flags), (server.fileno(), select.KQ_FILTER_WRITE, flags)]) @@ -143,7 +143,7 @@ class TestKQueue(unittest.TestCase): events = [(e.ident, e.filter, e.flags) for e in events] events.sort() - self.assertEquals(events, [ + self.assertEqual(events, [ (client.fileno(), select.KQ_FILTER_WRITE, flags), (client.fileno(), select.KQ_FILTER_READ, flags), (server.fileno(), select.KQ_FILTER_WRITE, flags), @@ -166,7 +166,7 @@ class TestKQueue(unittest.TestCase): events = kq.control([], 4, 0.99) events = [(e.ident, e.filter, e.flags) for e in events] events.sort() - self.assertEquals(events, [ + self.assertEqual(events, [ (server.fileno(), select.KQ_FILTER_WRITE, flags)]) client.close() @@ -183,7 +183,7 @@ class TestKQueue(unittest.TestCase): r = kq.control([event1, event2], 1, 1) self.assertTrue(r) self.assertFalse(r[0].flags & select.KQ_EV_ERROR) - self.assertEquals(b.recv(r[0].data), b'foo') + self.assertEqual(b.recv(r[0].data), b'foo') a.close() b.close() diff --git a/Lib/test/test_linecache.py b/Lib/test/test_linecache.py index 88346be..407bebc 100644 --- a/Lib/test/test_linecache.py +++ b/Lib/test/test_linecache.py @@ -42,31 +42,31 @@ class LineCacheTests(unittest.TestCase): getline = linecache.getline # Bad values for line number should return an empty string - self.assertEquals(getline(FILENAME, 2**15), EMPTY) - self.assertEquals(getline(FILENAME, -1), EMPTY) + self.assertEqual(getline(FILENAME, 2**15), EMPTY) + self.assertEqual(getline(FILENAME, -1), EMPTY) # Float values currently raise TypeError, should it? self.assertRaises(TypeError, getline, FILENAME, 1.1) # Bad filenames should return an empty string - self.assertEquals(getline(EMPTY, 1), EMPTY) - self.assertEquals(getline(INVALID_NAME, 1), EMPTY) + self.assertEqual(getline(EMPTY, 1), EMPTY) + self.assertEqual(getline(INVALID_NAME, 1), EMPTY) # Check whether lines correspond to those from file iteration for entry in TESTS: filename = os.path.join(TEST_PATH, entry) + '.py' for index, line in enumerate(open(filename)): - self.assertEquals(line, getline(filename, index + 1)) + self.assertEqual(line, getline(filename, index + 1)) # Check module loading for entry in MODULES: filename = os.path.join(MODULE_PATH, entry) + '.py' for index, line in enumerate(open(filename)): - self.assertEquals(line, getline(filename, index + 1)) + self.assertEqual(line, getline(filename, index + 1)) # Check that bogus data isn't returned (issue #1309567) empty = linecache.getlines('a/b/c/__init__.py') - self.assertEquals(empty, []) + self.assertEqual(empty, []) def test_no_ending_newline(self): self.addCleanup(support.unlink, support.TESTFN) @@ -84,12 +84,12 @@ class LineCacheTests(unittest.TestCase): # Are all files cached? cached_empty = [fn for fn in cached if fn not in linecache.cache] - self.assertEquals(cached_empty, []) + self.assertEqual(cached_empty, []) # Can we clear the cache? linecache.clearcache() cached_empty = [fn for fn in cached if fn in linecache.cache] - self.assertEquals(cached_empty, []) + self.assertEqual(cached_empty, []) def test_checkcache(self): getline = linecache.getline @@ -104,7 +104,7 @@ class LineCacheTests(unittest.TestCase): source_list = [] with open(source_name) as source: for index, line in enumerate(source): - self.assertEquals(line, getline(source_name, index + 1)) + self.assertEqual(line, getline(source_name, index + 1)) source_list.append(line) with open(source_name, 'w') as source: @@ -115,13 +115,13 @@ class LineCacheTests(unittest.TestCase): # Check that the cache matches the old contents for index, line in enumerate(source_list): - self.assertEquals(line, getline(source_name, index + 1)) + self.assertEqual(line, getline(source_name, index + 1)) # Update the cache and check whether it matches the new source file linecache.checkcache(source_name) with open(source_name) as source: for index, line in enumerate(source): - self.assertEquals(line, getline(source_name, index + 1)) + self.assertEqual(line, getline(source_name, index + 1)) source_list.append(line) def test_main(): diff --git a/Lib/test/test_linuxaudiodev.py b/Lib/test/test_linuxaudiodev.py index 3772a58..fef46b4 100644 --- a/Lib/test/test_linuxaudiodev.py +++ b/Lib/test/test_linuxaudiodev.py @@ -61,29 +61,29 @@ class LinuxAudioDevTests(unittest.TestCase): try: self.dev.setparameters(-1, size, nchannels, fmt) except ValueError, err: - self.assertEquals(err.args[0], "expected rate >= 0, not -1") + self.assertEqual(err.args[0], "expected rate >= 0, not -1") try: self.dev.setparameters(rate, -2, nchannels, fmt) except ValueError, err: - self.assertEquals(err.args[0], "expected sample size >= 0, not -2") + self.assertEqual(err.args[0], "expected sample size >= 0, not -2") try: self.dev.setparameters(rate, size, 3, fmt) except ValueError, err: - self.assertEquals(err.args[0], "nchannels must be 1 or 2, not 3") + self.assertEqual(err.args[0], "nchannels must be 1 or 2, not 3") try: self.dev.setparameters(rate, size, nchannels, 177) except ValueError, err: - self.assertEquals(err.args[0], "unknown audio encoding: 177") + self.assertEqual(err.args[0], "unknown audio encoding: 177") try: self.dev.setparameters(rate, size, nchannels, linuxaudiodev.AFMT_U16_LE) except ValueError, err: - self.assertEquals(err.args[0], "for linear unsigned 16-bit little-endian " - "audio, expected sample size 16, not 8") + self.assertEqual(err.args[0], "for linear unsigned 16-bit little-endian " + "audio, expected sample size 16, not 8") try: self.dev.setparameters(rate, 16, nchannels, fmt) except ValueError, err: - self.assertEquals(err.args[0], "for linear unsigned 8-bit audio, expected " - "sample size 8, not 16") + self.assertEqual(err.args[0], "for linear unsigned 8-bit audio, expected " + "sample size 8, not 16") def test_main(): try: diff --git a/Lib/test/test_logging.py b/Lib/test/test_logging.py index ed17d15..9f8374a 100644 --- a/Lib/test/test_logging.py +++ b/Lib/test/test_logging.py @@ -120,13 +120,13 @@ class BaseTest(unittest.TestCase): except AttributeError: # StringIO.StringIO lacks a reset() method. actual_lines = stream.getvalue().splitlines() - self.assertEquals(len(actual_lines), len(expected_values)) + self.assertEqual(len(actual_lines), len(expected_values)) for actual, expected in zip(actual_lines, expected_values): match = pat.search(actual) if not match: self.fail("Log line does not match expected pattern:\n" + actual) - self.assertEquals(tuple(match.groups()), expected) + self.assertEqual(tuple(match.groups()), expected) s = stream.read() if s: self.fail("Remaining output at end of log stream:\n" + s) @@ -692,7 +692,7 @@ class ConfigFileTest(BaseTest): except RuntimeError: logging.exception("just testing") sys.stdout.seek(0) - self.assertEquals(output.getvalue(), + self.assertEqual(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty self.assert_log_lines([]) @@ -811,7 +811,7 @@ class SocketHandlerTest(BaseTest): logger = logging.getLogger("tcp") logger.error("spam") logger.debug("eggs") - self.assertEquals(self.get_output(), "spam\neggs\n") + self.assertEqual(self.get_output(), "spam\neggs\n") class MemoryTest(BaseTest): @@ -1527,7 +1527,7 @@ class ConfigDictTest(BaseTest): except RuntimeError: logging.exception("just testing") sys.stdout.seek(0) - self.assertEquals(output.getvalue(), + self.assertEqual(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty self.assert_log_lines([]) @@ -1542,7 +1542,7 @@ class ConfigDictTest(BaseTest): except RuntimeError: logging.exception("just testing") sys.stdout.seek(0) - self.assertEquals(output.getvalue(), + self.assertEqual(output.getvalue(), "ERROR:root:just testing\nGot a [RuntimeError]\n") # Original logger output is empty self.assert_log_lines([]) diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py index 9706a8e..58cfc3a 100644 --- a/Lib/test/test_long.py +++ b/Lib/test/test_long.py @@ -530,9 +530,9 @@ class LongTest(unittest.TestCase): try: long(TruncReturnsNonIntegral()) except TypeError as e: - self.assertEquals(str(e), - "__trunc__ returned non-Integral" - " (type NonIntegral)") + self.assertEqual(str(e), + "__trunc__ returned non-Integral" + " (type NonIntegral)") else: self.fail("Failed to raise TypeError with %s" % ((base, trunc_result_base),)) diff --git a/Lib/test/test_macos.py b/Lib/test/test_macos.py index 465d304..5af5105 100644 --- a/Lib/test/test_macos.py +++ b/Lib/test/test_macos.py @@ -23,8 +23,8 @@ class TestMacOS(unittest.TestCase): test_support.TESTFN]) cr, tp = MacOS.GetCreatorAndType(test_support.TESTFN) - self.assertEquals(tp, 'ABCD') - self.assertEquals(cr, 'EFGH') + self.assertEqual(tp, 'ABCD') + self.assertEqual(cr, 'EFGH') finally: os.unlink(test_support.TESTFN) @@ -42,8 +42,8 @@ class TestMacOS(unittest.TestCase): 'ABCD', 'EFGH') cr, tp = MacOS.GetCreatorAndType(test_support.TESTFN) - self.assertEquals(cr, 'ABCD') - self.assertEquals(tp, 'EFGH') + self.assertEqual(cr, 'ABCD') + self.assertEqual(tp, 'EFGH') data = subprocess.Popen(["/Developer/Tools/GetFileInfo", test_support.TESTFN], stdout=subprocess.PIPE).communicate()[0] @@ -56,8 +56,8 @@ class TestMacOS(unittest.TestCase): if ln.startswith('creator:'): cr = ln.split()[-1][1:-1] - self.assertEquals(cr, 'ABCD') - self.assertEquals(tp, 'EFGH') + self.assertEqual(cr, 'ABCD') + self.assertEqual(tp, 'EFGH') finally: os.unlink(test_support.TESTFN) @@ -77,14 +77,14 @@ class TestMacOS(unittest.TestCase): fp = open(test_support.TESTFN, 'r') data = fp.read() fp.close() - self.assertEquals(data, 'hello world\n') + self.assertEqual(data, 'hello world\n') rfp = MacOS.openrf(test_support.TESTFN, '*rb') data = rfp.read(100) data2 = rfp.read(100) rfp.close() - self.assertEquals(data, 'goodbye world\n') - self.assertEquals(data2, '') + self.assertEqual(data, 'goodbye world\n') + self.assertEqual(data2, '') finally: diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py index 7e21862..10a5161 100644 --- a/Lib/test/test_marshal.py +++ b/Lib/test/test_marshal.py @@ -210,8 +210,8 @@ class BugsTestCase(unittest.TestCase): def test_version_argument(self): # Python 2.4.0 crashes for any call to marshal.dumps(x, y) - self.assertEquals(marshal.loads(marshal.dumps(5, 0)), 5) - self.assertEquals(marshal.loads(marshal.dumps(5, 1)), 5) + self.assertEqual(marshal.loads(marshal.dumps(5, 0)), 5) + self.assertEqual(marshal.loads(marshal.dumps(5, 1)), 5) def test_fuzz(self): # simple test that it's at least not *totally* trivial to diff --git a/Lib/test/test_math.py b/Lib/test/test_math.py index 7d49ed9..973d1ab 100644 --- a/Lib/test/test_math.py +++ b/Lib/test/test_math.py @@ -158,7 +158,7 @@ class MathTests(unittest.TestCase): self.ftest('acosh(2)', math.acosh(2), 1.3169578969248168) self.assertRaises(ValueError, math.acosh, 0) self.assertRaises(ValueError, math.acosh, -1) - self.assertEquals(math.acosh(INF), INF) + self.assertEqual(math.acosh(INF), INF) self.assertRaises(ValueError, math.acosh, NINF) self.assertTrue(math.isnan(math.acosh(NAN))) @@ -176,8 +176,8 @@ class MathTests(unittest.TestCase): self.ftest('asinh(0)', math.asinh(0), 0) self.ftest('asinh(1)', math.asinh(1), 0.88137358701954305) self.ftest('asinh(-1)', math.asinh(-1), -0.88137358701954305) - self.assertEquals(math.asinh(INF), INF) - self.assertEquals(math.asinh(NINF), NINF) + self.assertEqual(math.asinh(INF), INF) + self.assertEqual(math.asinh(NINF), NINF) self.assertTrue(math.isnan(math.asinh(NAN))) def testAtan(self): @@ -264,17 +264,17 @@ class MathTests(unittest.TestCase): def testCeil(self): self.assertRaises(TypeError, math.ceil) # These types will be int in py3k. - self.assertEquals(float, type(math.ceil(1))) - self.assertEquals(float, type(math.ceil(1L))) - self.assertEquals(float, type(math.ceil(1.0))) + self.assertEqual(float, type(math.ceil(1))) + self.assertEqual(float, type(math.ceil(1L))) + self.assertEqual(float, type(math.ceil(1.0))) self.ftest('ceil(0.5)', math.ceil(0.5), 1) self.ftest('ceil(1.0)', math.ceil(1.0), 1) self.ftest('ceil(1.5)', math.ceil(1.5), 2) self.ftest('ceil(-0.5)', math.ceil(-0.5), 0) self.ftest('ceil(-1.0)', math.ceil(-1.0), -1) self.ftest('ceil(-1.5)', math.ceil(-1.5), -1) - self.assertEquals(math.ceil(INF), INF) - self.assertEquals(math.ceil(NINF), NINF) + self.assertEqual(math.ceil(INF), INF) + self.assertEqual(math.ceil(NINF), NINF) self.assertTrue(math.isnan(math.ceil(NAN))) class TestCeil(object): @@ -300,19 +300,19 @@ class MathTests(unittest.TestCase): self.assertRaises(TypeError, math.copysign) # copysign should let us distinguish signs of zeros - self.assertEquals(math.copysign(1., 0.), 1.) - self.assertEquals(math.copysign(1., -0.), -1.) - self.assertEquals(math.copysign(INF, 0.), INF) - self.assertEquals(math.copysign(INF, -0.), NINF) - self.assertEquals(math.copysign(NINF, 0.), INF) - self.assertEquals(math.copysign(NINF, -0.), NINF) + self.assertEqual(math.copysign(1., 0.), 1.) + self.assertEqual(math.copysign(1., -0.), -1.) + self.assertEqual(math.copysign(INF, 0.), INF) + self.assertEqual(math.copysign(INF, -0.), NINF) + self.assertEqual(math.copysign(NINF, 0.), INF) + self.assertEqual(math.copysign(NINF, -0.), NINF) # and of infinities - self.assertEquals(math.copysign(1., INF), 1.) - self.assertEquals(math.copysign(1., NINF), -1.) - self.assertEquals(math.copysign(INF, INF), INF) - self.assertEquals(math.copysign(INF, NINF), NINF) - self.assertEquals(math.copysign(NINF, INF), INF) - self.assertEquals(math.copysign(NINF, NINF), NINF) + self.assertEqual(math.copysign(1., INF), 1.) + self.assertEqual(math.copysign(1., NINF), -1.) + self.assertEqual(math.copysign(INF, INF), INF) + self.assertEqual(math.copysign(INF, NINF), NINF) + self.assertEqual(math.copysign(NINF, INF), INF) + self.assertEqual(math.copysign(NINF, NINF), NINF) self.assertTrue(math.isnan(math.copysign(NAN, 1.))) self.assertTrue(math.isnan(math.copysign(NAN, INF))) self.assertTrue(math.isnan(math.copysign(NAN, NINF))) @@ -322,7 +322,7 @@ class MathTests(unittest.TestCase): # given platform. self.assertTrue(math.isinf(math.copysign(INF, NAN))) # similarly, copysign(2., NAN) could be 2. or -2. - self.assertEquals(abs(math.copysign(2., NAN)), 2.) + self.assertEqual(abs(math.copysign(2., NAN)), 2.) def testCos(self): self.assertRaises(TypeError, math.cos) @@ -342,8 +342,8 @@ class MathTests(unittest.TestCase): self.assertRaises(TypeError, math.cosh) self.ftest('cosh(0)', math.cosh(0), 1) self.ftest('cosh(2)-2*cosh(1)**2', math.cosh(2)-2*math.cosh(1)**2, -1) # Thanks to Lambert - self.assertEquals(math.cosh(INF), INF) - self.assertEquals(math.cosh(NINF), INF) + self.assertEqual(math.cosh(INF), INF) + self.assertEqual(math.cosh(NINF), INF) self.assertTrue(math.isnan(math.cosh(NAN))) def testDegrees(self): @@ -357,8 +357,8 @@ class MathTests(unittest.TestCase): self.ftest('exp(-1)', math.exp(-1), 1/math.e) self.ftest('exp(0)', math.exp(0), 1) self.ftest('exp(1)', math.exp(1), math.e) - self.assertEquals(math.exp(INF), INF) - self.assertEquals(math.exp(NINF), 0.) + self.assertEqual(math.exp(INF), INF) + self.assertEqual(math.exp(NINF), 0.) self.assertTrue(math.isnan(math.exp(NAN))) def testFabs(self): @@ -384,9 +384,9 @@ class MathTests(unittest.TestCase): def testFloor(self): self.assertRaises(TypeError, math.floor) # These types will be int in py3k. - self.assertEquals(float, type(math.floor(1))) - self.assertEquals(float, type(math.floor(1L))) - self.assertEquals(float, type(math.floor(1.0))) + self.assertEqual(float, type(math.floor(1))) + self.assertEqual(float, type(math.floor(1L))) + self.assertEqual(float, type(math.floor(1.0))) self.ftest('floor(0.5)', math.floor(0.5), 0) self.ftest('floor(1.0)', math.floor(1.0), 1) self.ftest('floor(1.5)', math.floor(1.5), 1) @@ -397,8 +397,8 @@ class MathTests(unittest.TestCase): # This fails on some platforms - so check it here self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167) self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167) - self.assertEquals(math.ceil(INF), INF) - self.assertEquals(math.ceil(NINF), NINF) + self.assertEqual(math.ceil(INF), INF) + self.assertEqual(math.ceil(NINF), NINF) self.assertTrue(math.isnan(math.floor(NAN))) class TestFloor(object): @@ -429,12 +429,12 @@ class MathTests(unittest.TestCase): self.assertRaises(ValueError, math.fmod, INF, 1.) self.assertRaises(ValueError, math.fmod, NINF, 1.) self.assertRaises(ValueError, math.fmod, INF, 0.) - self.assertEquals(math.fmod(3.0, INF), 3.0) - self.assertEquals(math.fmod(-3.0, INF), -3.0) - self.assertEquals(math.fmod(3.0, NINF), 3.0) - self.assertEquals(math.fmod(-3.0, NINF), -3.0) - self.assertEquals(math.fmod(0.0, 3.0), 0.0) - self.assertEquals(math.fmod(0.0, NINF), 0.0) + self.assertEqual(math.fmod(3.0, INF), 3.0) + self.assertEqual(math.fmod(-3.0, INF), -3.0) + self.assertEqual(math.fmod(3.0, NINF), 3.0) + self.assertEqual(math.fmod(-3.0, NINF), -3.0) + self.assertEqual(math.fmod(0.0, 3.0), 0.0) + self.assertEqual(math.fmod(0.0, NINF), 0.0) def testFrexp(self): self.assertRaises(TypeError, math.frexp) @@ -450,8 +450,8 @@ class MathTests(unittest.TestCase): testfrexp('frexp(1)', math.frexp(1), (0.5, 1)) testfrexp('frexp(2)', math.frexp(2), (0.5, 2)) - self.assertEquals(math.frexp(INF)[0], INF) - self.assertEquals(math.frexp(NINF)[0], NINF) + self.assertEqual(math.frexp(INF)[0], INF) + self.assertEqual(math.frexp(NINF)[0], NINF) self.assertTrue(math.isnan(math.frexp(NAN)[0])) @requires_IEEE_754 @@ -564,28 +564,28 @@ class MathTests(unittest.TestCase): self.ftest('ldexp(-1,1)', math.ldexp(-1,1), -2) self.assertRaises(OverflowError, math.ldexp, 1., 1000000) self.assertRaises(OverflowError, math.ldexp, -1., 1000000) - self.assertEquals(math.ldexp(1., -1000000), 0.) - self.assertEquals(math.ldexp(-1., -1000000), -0.) - self.assertEquals(math.ldexp(INF, 30), INF) - self.assertEquals(math.ldexp(NINF, -213), NINF) + self.assertEqual(math.ldexp(1., -1000000), 0.) + self.assertEqual(math.ldexp(-1., -1000000), -0.) + self.assertEqual(math.ldexp(INF, 30), INF) + self.assertEqual(math.ldexp(NINF, -213), NINF) self.assertTrue(math.isnan(math.ldexp(NAN, 0))) # large second argument for n in [10**5, 10L**5, 10**10, 10L**10, 10**20, 10**40]: - self.assertEquals(math.ldexp(INF, -n), INF) - self.assertEquals(math.ldexp(NINF, -n), NINF) - self.assertEquals(math.ldexp(1., -n), 0.) - self.assertEquals(math.ldexp(-1., -n), -0.) - self.assertEquals(math.ldexp(0., -n), 0.) - self.assertEquals(math.ldexp(-0., -n), -0.) + self.assertEqual(math.ldexp(INF, -n), INF) + self.assertEqual(math.ldexp(NINF, -n), NINF) + self.assertEqual(math.ldexp(1., -n), 0.) + self.assertEqual(math.ldexp(-1., -n), -0.) + self.assertEqual(math.ldexp(0., -n), 0.) + self.assertEqual(math.ldexp(-0., -n), -0.) self.assertTrue(math.isnan(math.ldexp(NAN, -n))) self.assertRaises(OverflowError, math.ldexp, 1., n) self.assertRaises(OverflowError, math.ldexp, -1., n) - self.assertEquals(math.ldexp(0., n), 0.) - self.assertEquals(math.ldexp(-0., n), -0.) - self.assertEquals(math.ldexp(INF, n), INF) - self.assertEquals(math.ldexp(NINF, n), NINF) + self.assertEqual(math.ldexp(0., n), 0.) + self.assertEqual(math.ldexp(-0., n), -0.) + self.assertEqual(math.ldexp(INF, n), INF) + self.assertEqual(math.ldexp(NINF, n), NINF) self.assertTrue(math.isnan(math.ldexp(NAN, n))) def testLog(self): @@ -596,7 +596,7 @@ class MathTests(unittest.TestCase): self.ftest('log(32,2)', math.log(32,2), 5) self.ftest('log(10**40, 10)', math.log(10**40, 10), 40) self.ftest('log(10**40, 10**20)', math.log(10**40, 10**20), 2) - self.assertEquals(math.log(INF), INF) + self.assertEqual(math.log(INF), INF) self.assertRaises(ValueError, math.log, NINF) self.assertTrue(math.isnan(math.log(NAN))) @@ -606,19 +606,19 @@ class MathTests(unittest.TestCase): self.ftest('log1p(0)', math.log1p(0), 0) self.ftest('log1p(e-1)', math.log1p(math.e-1), 1) self.ftest('log1p(1)', math.log1p(1), math.log(2)) - self.assertEquals(math.log1p(INF), INF) + self.assertEqual(math.log1p(INF), INF) self.assertRaises(ValueError, math.log1p, NINF) self.assertTrue(math.isnan(math.log1p(NAN))) n= 2**90 - self.assertAlmostEquals(math.log1p(n), 62.383246250395075) - self.assertAlmostEquals(math.log1p(n), math.log1p(float(n))) + self.assertAlmostEqual(math.log1p(n), 62.383246250395075) + self.assertAlmostEqual(math.log1p(n), math.log1p(float(n))) def testLog10(self): self.assertRaises(TypeError, math.log10) self.ftest('log10(0.1)', math.log10(0.1), -1) self.ftest('log10(1)', math.log10(1), 0) self.ftest('log10(10)', math.log10(10), 1) - self.assertEquals(math.log(INF), INF) + self.assertEqual(math.log(INF), INF) self.assertRaises(ValueError, math.log10, NINF) self.assertTrue(math.isnan(math.log10(NAN))) @@ -634,8 +634,8 @@ class MathTests(unittest.TestCase): testmodf('modf(1.5)', math.modf(1.5), (0.5, 1.0)) testmodf('modf(-1.5)', math.modf(-1.5), (-0.5, -1.0)) - self.assertEquals(math.modf(INF), (0.0, INF)) - self.assertEquals(math.modf(NINF), (-0.0, NINF)) + self.assertEqual(math.modf(INF), (0.0, INF)) + self.assertEqual(math.modf(NINF), (-0.0, NINF)) modf_nan = math.modf(NAN) self.assertTrue(math.isnan(modf_nan[0])) @@ -814,8 +814,8 @@ class MathTests(unittest.TestCase): self.ftest('sinh(0)', math.sinh(0), 0) self.ftest('sinh(1)**2-cosh(1)**2', math.sinh(1)**2-math.cosh(1)**2, -1) self.ftest('sinh(1)+sinh(-1)', math.sinh(1)+math.sinh(-1), 0) - self.assertEquals(math.sinh(INF), INF) - self.assertEquals(math.sinh(NINF), NINF) + self.assertEqual(math.sinh(INF), INF) + self.assertEqual(math.sinh(NINF), NINF) self.assertTrue(math.isnan(math.sinh(NAN))) def testSqrt(self): @@ -823,7 +823,7 @@ class MathTests(unittest.TestCase): self.ftest('sqrt(0)', math.sqrt(0), 0) self.ftest('sqrt(1)', math.sqrt(1), 1) self.ftest('sqrt(4)', math.sqrt(4), 2) - self.assertEquals(math.sqrt(INF), INF) + self.assertEqual(math.sqrt(INF), INF) self.assertRaises(ValueError, math.sqrt, NINF) self.assertTrue(math.isnan(math.sqrt(NAN))) diff --git a/Lib/test/test_memoryio.py b/Lib/test/test_memoryio.py index 8d95a64..c494759 100644 --- a/Lib/test/test_memoryio.py +++ b/Lib/test/test_memoryio.py @@ -23,17 +23,17 @@ class MemorySeekTestMixin: buf = self.buftype("1234567890") bytesIo = self.ioclass(buf) - self.assertEquals(buf[:1], bytesIo.read(1)) - self.assertEquals(buf[1:5], bytesIo.read(4)) - self.assertEquals(buf[5:], bytesIo.read(900)) - self.assertEquals(self.EOF, bytesIo.read()) + self.assertEqual(buf[:1], bytesIo.read(1)) + self.assertEqual(buf[1:5], bytesIo.read(4)) + self.assertEqual(buf[5:], bytesIo.read(900)) + self.assertEqual(self.EOF, bytesIo.read()) def testReadNoArgs(self): buf = self.buftype("1234567890") bytesIo = self.ioclass(buf) - self.assertEquals(buf, bytesIo.read()) - self.assertEquals(self.EOF, bytesIo.read()) + self.assertEqual(buf, bytesIo.read()) + self.assertEqual(self.EOF, bytesIo.read()) def testSeek(self): buf = self.buftype("1234567890") @@ -41,21 +41,21 @@ class MemorySeekTestMixin: bytesIo.read(5) bytesIo.seek(0) - self.assertEquals(buf, bytesIo.read()) + self.assertEqual(buf, bytesIo.read()) bytesIo.seek(3) - self.assertEquals(buf[3:], bytesIo.read()) + self.assertEqual(buf[3:], bytesIo.read()) self.assertRaises(TypeError, bytesIo.seek, 0.0) def testTell(self): buf = self.buftype("1234567890") bytesIo = self.ioclass(buf) - self.assertEquals(0, bytesIo.tell()) + self.assertEqual(0, bytesIo.tell()) bytesIo.seek(5) - self.assertEquals(5, bytesIo.tell()) + self.assertEqual(5, bytesIo.tell()) bytesIo.seek(10000) - self.assertEquals(10000, bytesIo.tell()) + self.assertEqual(10000, bytesIo.tell()) class MemoryTestMixin: @@ -618,7 +618,7 @@ class CBytesIOTest(PyBytesIOTest): self.assertEqual(len(state), 3) bytearray(state[0]) # Check if state[0] supports the buffer interface. self.assertIsInstance(state[1], int) - self.assert_(isinstance(state[2], dict) or state[2] is None) + self.assertTrue(isinstance(state[2], dict) or state[2] is None) memio.close() self.assertRaises(ValueError, memio.__getstate__) @@ -664,7 +664,7 @@ class CStringIOTest(PyStringIOTest): self.assertIsInstance(state[0], unicode) self.assertIsInstance(state[1], str) self.assertIsInstance(state[2], int) - self.assert_(isinstance(state[3], dict) or state[3] is None) + self.assertTrue(isinstance(state[3], dict) or state[3] is None) memio.close() self.assertRaises(ValueError, memio.__getstate__) diff --git a/Lib/test/test_memoryview.py b/Lib/test/test_memoryview.py index 611f57d..61e60fb 100644 --- a/Lib/test/test_memoryview.py +++ b/Lib/test/test_memoryview.py @@ -27,11 +27,11 @@ class AbstractMemoryTests: b = tp(self._source) oldrefcount = sys.getrefcount(b) m = self._view(b) - self.assertEquals(m[0], item(b"a")) + self.assertEqual(m[0], item(b"a")) self.assertIsInstance(m[0], bytes) - self.assertEquals(m[5], item(b"f")) - self.assertEquals(m[-1], item(b"f")) - self.assertEquals(m[-6], item(b"a")) + self.assertEqual(m[5], item(b"f")) + self.assertEqual(m[-1], item(b"f")) + self.assertEqual(m[-6], item(b"a")) # Bounds checking self.assertRaises(IndexError, lambda: m[6]) self.assertRaises(IndexError, lambda: m[-7]) @@ -42,7 +42,7 @@ class AbstractMemoryTests: self.assertRaises(TypeError, lambda: m[0.0]) self.assertRaises(TypeError, lambda: m["a"]) m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_getitem(self): for tp in self._types: @@ -72,7 +72,7 @@ class AbstractMemoryTests: self.assertRaises(TypeError, setitem, 65) self.assertRaises(TypeError, setitem, memoryview(b"a")) m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_setitem_writable(self): if not self.rw_type: @@ -115,7 +115,7 @@ class AbstractMemoryTests: self.assertRaises(ValueError, setitem, slice(0,2), b"a") m = None - self.assertEquals(sys.getrefcount(b), oldrefcount) + self.assertEqual(sys.getrefcount(b), oldrefcount) def test_delitem(self): for tp in self._types: @@ -133,14 +133,14 @@ class AbstractMemoryTests: # This calls self.getitem_type() on each separate byte of b"abcdef" expected = b"".join( self.getitem_type(c) for c in b"abcdef") - self.assertEquals(b, expected) + self.assertEqual(b, expected) self.assertIsInstance(b, bytes) def test_tolist(self): for tp in self._types: m = self._view(tp(self._source)) l = m.tolist() - self.assertEquals(l, map(ord, b"abcdef")) + self.assertEqual(l, map(ord, b"abcdef")) def test_compare(self): # memoryviews can compare for equality with other objects @@ -170,27 +170,27 @@ class AbstractMemoryTests: def check_attributes_with_type(self, tp): m = self._view(tp(self._source)) - self.assertEquals(m.format, self.format) + self.assertEqual(m.format, self.format) self.assertIsInstance(m.format, str) - self.assertEquals(m.itemsize, self.itemsize) - self.assertEquals(m.ndim, 1) - self.assertEquals(m.shape, (6,)) - self.assertEquals(len(m), 6) - self.assertEquals(m.strides, (self.itemsize,)) - self.assertEquals(m.suboffsets, None) + self.assertEqual(m.itemsize, self.itemsize) + self.assertEqual(m.ndim, 1) + self.assertEqual(m.shape, (6,)) + self.assertEqual(len(m), 6) + self.assertEqual(m.strides, (self.itemsize,)) + self.assertEqual(m.suboffsets, None) return m def test_attributes_readonly(self): if not self.ro_type: return m = self.check_attributes_with_type(self.ro_type) - self.assertEquals(m.readonly, True) + self.assertEqual(m.readonly, True) def test_attributes_writable(self): if not self.rw_type: return m = self.check_attributes_with_type(self.rw_type) - self.assertEquals(m.readonly, False) + self.assertEqual(m.readonly, False) # Disabled: unicode uses the old buffer API in 2.x @@ -203,9 +203,9 @@ class AbstractMemoryTests: #oldviewrefcount = sys.getrefcount(m) #s = unicode(m, "utf-8") #self._check_contents(tp, b, s.encode("utf-8")) - #self.assertEquals(sys.getrefcount(m), oldviewrefcount) + #self.assertEqual(sys.getrefcount(m), oldviewrefcount) #m = None - #self.assertEquals(sys.getrefcount(b), oldrefcount) + #self.assertEqual(sys.getrefcount(b), oldrefcount) def test_gc(self): for tp in self._types: @@ -269,7 +269,7 @@ class BaseMemoryviewTests: return memoryview(obj) def _check_contents(self, tp, obj, contents): - self.assertEquals(obj, tp(contents)) + self.assertEqual(obj, tp(contents)) class BaseMemorySliceTests: source_bytes = b"XabcdefY" @@ -279,14 +279,14 @@ class BaseMemorySliceTests: return m[1:7] def _check_contents(self, tp, obj, contents): - self.assertEquals(obj[1:7], tp(contents)) + self.assertEqual(obj[1:7], tp(contents)) def test_refs(self): for tp in self._types: m = memoryview(tp(self._source)) oldrefcount = sys.getrefcount(m) m[1:2] - self.assertEquals(sys.getrefcount(m), oldrefcount) + self.assertEqual(sys.getrefcount(m), oldrefcount) class BaseMemorySliceSliceTests: source_bytes = b"XabcdefY" @@ -296,7 +296,7 @@ class BaseMemorySliceSliceTests: return m[:7][1:] def _check_contents(self, tp, obj, contents): - self.assertEquals(obj[1:7], tp(contents)) + self.assertEqual(obj[1:7], tp(contents)) # Concrete test classes @@ -323,7 +323,7 @@ class BytesMemoryviewTest(unittest.TestCase, #m = memoryview(a) #new_a = array.array('i', range(9, -1, -1)) #m[:] = new_a - #self.assertEquals(a, new_a) + #self.assertEqual(a, new_a) class BytesMemorySliceTest(unittest.TestCase, diff --git a/Lib/test/test_mhlib.py b/Lib/test/test_mhlib.py index f1349bc..996df44 100644 --- a/Lib/test/test_mhlib.py +++ b/Lib/test/test_mhlib.py @@ -148,7 +148,7 @@ class MhlibTests(unittest.TestCase): writeCurMessage('inbox', 2) mh = getMH() - eq = self.assertEquals + eq = self.assertEqual eq(mh.getprofile('Editor'), 'emacs') eq(mh.getprofile('not-set'), None) eq(mh.getpath(), os.path.abspath(_mhpath)) @@ -171,7 +171,7 @@ class MhlibTests(unittest.TestCase): def test_listfolders(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual folders = mh.listfolders() folders.sort() @@ -198,7 +198,7 @@ class MhlibTests(unittest.TestCase): def test_sequence(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual writeCurMessage('wide', 55) f = mh.openfolder('wide') @@ -253,7 +253,7 @@ class MhlibTests(unittest.TestCase): def test_modify(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual mh.makefolder("dummy1") self.assertIn("dummy1", mh.listfolders()) @@ -315,7 +315,7 @@ class MhlibTests(unittest.TestCase): def test_read(self): mh = getMH() - eq = self.assertEquals + eq = self.assertEqual f = mh.openfolder('inbox') msg = f.openmessage(1) diff --git a/Lib/test/test_minidom.py b/Lib/test/test_minidom.py index 8fbc578..90f7d51 100644 --- a/Lib/test/test_minidom.py +++ b/Lib/test/test_minidom.py @@ -748,7 +748,7 @@ class MinidomTest(unittest.TestCase): def check_clone_pi(self, deep, testName): doc = parseString("") pi = doc.firstChild - self.assertEquals(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE) + self.assertEqual(pi.nodeType, Node.PROCESSING_INSTRUCTION_NODE) clone = pi.cloneNode(deep) self.confirm(clone.target == pi.target and clone.data == pi.data) @@ -948,7 +948,7 @@ class MinidomTest(unittest.TestCase): def testBug0777884(self): doc = parseString("text") text = doc.documentElement.childNodes[0] - self.assertEquals(text.nodeType, Node.TEXT_NODE) + self.assertEqual(text.nodeType, Node.TEXT_NODE) # Should run quietly, doing nothing. text.normalize() doc.unlink() @@ -1226,7 +1226,7 @@ class MinidomTest(unittest.TestCase): doc = parseString("a") elem = doc.documentElement text = elem.childNodes[0] - self.assertEquals(text.nodeType, Node.TEXT_NODE) + self.assertEqual(text.nodeType, Node.TEXT_NODE) self.checkWholeText(text, "a") elem.appendChild(doc.createTextNode("b")) diff --git a/Lib/test/test_mmap.py b/Lib/test/test_mmap.py index a3998e2..b62ed2e 100644 --- a/Lib/test/test_mmap.py +++ b/Lib/test/test_mmap.py @@ -417,7 +417,7 @@ class MmapTests(unittest.TestCase): data = "".join(reversed(data)) L[start:stop:step] = data m[start:stop:step] = data - self.assertEquals(m[:], "".join(L)) + self.assertEqual(m[:], "".join(L)) def make_mmap_file (self, f, halfsize): # Write 2 pages worth of data to the file @@ -512,27 +512,27 @@ class MmapTests(unittest.TestCase): f.close() # Test write_byte() for i in xrange(len(data)): - self.assertEquals(m.tell(), i) + self.assertEqual(m.tell(), i) m.write_byte(data[i]) - self.assertEquals(m.tell(), i+1) + self.assertEqual(m.tell(), i+1) self.assertRaises(ValueError, m.write_byte, "x") - self.assertEquals(m[:], data) + self.assertEqual(m[:], data) # Test read_byte() m.seek(0) for i in xrange(len(data)): - self.assertEquals(m.tell(), i) - self.assertEquals(m.read_byte(), data[i]) - self.assertEquals(m.tell(), i+1) + self.assertEqual(m.tell(), i) + self.assertEqual(m.read_byte(), data[i]) + self.assertEqual(m.tell(), i+1) self.assertRaises(ValueError, m.read_byte) # Test read() m.seek(3) - self.assertEquals(m.read(3), "345") - self.assertEquals(m.tell(), 6) + self.assertEqual(m.read(3), "345") + self.assertEqual(m.tell(), 6) # Test write() m.seek(3) m.write("bar") - self.assertEquals(m.tell(), 6) - self.assertEquals(m[:], "012bar6789") + self.assertEqual(m.tell(), 6) + self.assertEqual(m[:], "012bar6789") m.seek(8) self.assertRaises(ValueError, m.write, "bar") @@ -547,8 +547,8 @@ class MmapTests(unittest.TestCase): m1[:] = data1 m2 = mmap.mmap(-1, len(data2), tagname="foo") m2[:] = data2 - self.assertEquals(m1[:], data2) - self.assertEquals(m2[:], data2) + self.assertEqual(m1[:], data2) + self.assertEqual(m2[:], data2) m2.close() m1.close() @@ -557,8 +557,8 @@ class MmapTests(unittest.TestCase): m1[:] = data1 m2 = mmap.mmap(-1, len(data2), tagname="boo") m2[:] = data2 - self.assertEquals(m1[:], data1) - self.assertEquals(m2[:], data2) + self.assertEqual(m1[:], data1) + self.assertEqual(m2[:], data2) m2.close() m1.close() diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py index f5873da..6521c03 100644 --- a/Lib/test/test_multiprocessing.py +++ b/Lib/test/test_multiprocessing.py @@ -183,30 +183,30 @@ class _TestProcess(BaseTestCase): current = self.current_process() if self.TYPE != 'threads': - self.assertEquals(p.authkey, current.authkey) - self.assertEquals(p.is_alive(), False) - self.assertEquals(p.daemon, True) + self.assertEqual(p.authkey, current.authkey) + self.assertEqual(p.is_alive(), False) + self.assertEqual(p.daemon, True) self.assertNotIn(p, self.active_children()) self.assertTrue(type(self.active_children()) is list) self.assertEqual(p.exitcode, None) p.start() - self.assertEquals(p.exitcode, None) - self.assertEquals(p.is_alive(), True) + self.assertEqual(p.exitcode, None) + self.assertEqual(p.is_alive(), True) self.assertIn(p, self.active_children()) - self.assertEquals(q.get(), args[1:]) - self.assertEquals(q.get(), kwargs) - self.assertEquals(q.get(), p.name) + self.assertEqual(q.get(), args[1:]) + self.assertEqual(q.get(), kwargs) + self.assertEqual(q.get(), p.name) if self.TYPE != 'threads': - self.assertEquals(q.get(), current.authkey) - self.assertEquals(q.get(), p.pid) + self.assertEqual(q.get(), current.authkey) + self.assertEqual(q.get(), p.pid) p.join() - self.assertEquals(p.exitcode, 0) - self.assertEquals(p.is_alive(), False) + self.assertEqual(p.exitcode, 0) + self.assertEqual(p.is_alive(), False) self.assertNotIn(p, self.active_children()) @classmethod diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py index c93ef86..6d117d6 100644 --- a/Lib/test/test_opcodes.py +++ b/Lib/test/test_opcodes.py @@ -72,35 +72,35 @@ class OpcodeTest(unittest.TestCase): f = eval('lambda: None') g = eval('lambda: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a: a') g = eval('lambda a: a') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a=1: a') g = eval('lambda a=1: a') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda: 0') g = eval('lambda: 1') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda: None') g = eval('lambda a: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a: None') g = eval('lambda b: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a: None') g = eval('lambda a=None: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) f = eval('lambda a=0: None') g = eval('lambda a=1: None') - self.assertNotEquals(f, g) + self.assertNotEqual(f, g) def test_modulo_of_string_subclasses(self): class MyString(str): diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py index a4650f4..81a8020 100644 --- a/Lib/test/test_operator.py +++ b/Lib/test/test_operator.py @@ -455,12 +455,12 @@ class OperatorTestCase(unittest.TestCase): f = operator.methodcaller('foo') self.assertRaises(IndexError, f, a) f = operator.methodcaller('foo', 1, 2) - self.assertEquals(f(a), 3) + self.assertEqual(f(a), 3) f = operator.methodcaller('bar') - self.assertEquals(f(a), 42) + self.assertEqual(f(a), 42) self.assertRaises(TypeError, f, a, a) f = operator.methodcaller('bar', f=5) - self.assertEquals(f(a), 5) + self.assertEqual(f(a), 5) def test_inplace(self): class C(object): diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py index bc8bb8a..f86ea01 100644 --- a/Lib/test/test_optparse.py +++ b/Lib/test/test_optparse.py @@ -427,19 +427,19 @@ class TestTypeAliases(BaseTest): def test_str_aliases_string(self): self.parser.add_option("-s", type="str") - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") def test_new_type_object(self): self.parser.add_option("-s", type=str) - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") self.parser.add_option("-x", type=int) - self.assertEquals(self.parser.get_option("-x").type, "int") + self.assertEqual(self.parser.get_option("-x").type, "int") def test_old_type_object(self): self.parser.add_option("-s", type=types.StringType) - self.assertEquals(self.parser.get_option("-s").type, "string") + self.assertEqual(self.parser.get_option("-s").type, "string") self.parser.add_option("-x", type=types.IntType) - self.assertEquals(self.parser.get_option("-x").type, "int") + self.assertEqual(self.parser.get_option("-x").type, "int") # Custom type for testing processing of default values. diff --git a/Lib/test/test_os.py b/Lib/test/test_os.py index e83d785..8bb8ce3 100644 --- a/Lib/test/test_os.py +++ b/Lib/test/test_os.py @@ -187,8 +187,8 @@ class StatAttributeTests(unittest.TestCase): result = os.stat(self.fname) # Make sure direct access works - self.assertEquals(result[stat.ST_SIZE], 3) - self.assertEquals(result.st_size, 3) + self.assertEqual(result[stat.ST_SIZE], 3) + self.assertEqual(result.st_size, 3) # Make sure all the attributes are there members = dir(result) @@ -199,8 +199,8 @@ class StatAttributeTests(unittest.TestCase): def trunc(x): return int(x) else: def trunc(x): return x - self.assertEquals(trunc(getattr(result, attr)), - result[getattr(stat, name)]) + self.assertEqual(trunc(getattr(result, attr)), + result[getattr(stat, name)]) self.assertIn(attr, members) try: @@ -254,13 +254,13 @@ class StatAttributeTests(unittest.TestCase): return # Make sure direct access works - self.assertEquals(result.f_bfree, result[3]) + self.assertEqual(result.f_bfree, result[3]) # Make sure all the attributes are there. members = ('bsize', 'frsize', 'blocks', 'bfree', 'bavail', 'files', 'ffree', 'favail', 'flag', 'namemax') for value, member in enumerate(members): - self.assertEquals(getattr(result, 'f_' + member), result[value]) + self.assertEqual(getattr(result, 'f_' + member), result[value]) # Make sure that assignment really fails try: @@ -295,7 +295,7 @@ class StatAttributeTests(unittest.TestCase): # time stamps in stat, but not in utime. os.utime(test_support.TESTFN, (st.st_atime, int(st.st_mtime-delta))) st2 = os.stat(test_support.TESTFN) - self.assertEquals(st2.st_mtime, int(st.st_mtime-delta)) + self.assertEqual(st2.st_mtime, int(st.st_mtime-delta)) # Restrict test to Win32, since there is no guarantee other # systems support centiseconds @@ -312,7 +312,7 @@ class StatAttributeTests(unittest.TestCase): def test_1565150(self): t1 = 1159195039.25 os.utime(self.fname, (t1, t1)) - self.assertEquals(os.stat(self.fname).st_mtime, t1) + self.assertEqual(os.stat(self.fname).st_mtime, t1) def test_1686475(self): # Verify that an open file can be stat'ed @@ -346,7 +346,7 @@ class EnvironTests(mapping_tests.BasicTestMappingProtocol): os.environ.update(HELLO="World") with os.popen("/bin/sh -c 'echo $HELLO'") as popen: value = popen.read().strip() - self.assertEquals(value, "World") + self.assertEqual(value, "World") class WalkTests(unittest.TestCase): """Tests for os.walk().""" diff --git a/Lib/test/test_parser.py b/Lib/test/test_parser.py index e208d53..33b91bd 100644 --- a/Lib/test/test_parser.py +++ b/Lib/test/test_parser.py @@ -19,8 +19,8 @@ class RoundtripLegalSyntaxTestCase(unittest.TestCase): except parser.ParserError, why: self.fail("could not roundtrip %r: %s" % (s, why)) - self.assertEquals(t, st2.totuple(), - "could not re-generate syntax tree") + self.assertEqual(t, st2.totuple(), + "could not re-generate syntax tree") def check_expr(self, s): self.roundtrip(parser.expr, s) @@ -547,14 +547,14 @@ class CompileTestCase(unittest.TestCase): def test_compile_expr(self): st = parser.expr('2 + 3') code = parser.compilest(st) - self.assertEquals(eval(code), 5) + self.assertEqual(eval(code), 5) def test_compile_suite(self): st = parser.suite('x = 2; y = x + 3') code = parser.compilest(st) globs = {} exec code in globs - self.assertEquals(globs['y'], 5) + self.assertEqual(globs['y'], 5) def test_compile_error(self): st = parser.suite('1 = 3 + 4') diff --git a/Lib/test/test_pep247.py b/Lib/test/test_pep247.py index 7d7425e..423d333 100644 --- a/Lib/test/test_pep247.py +++ b/Lib/test/test_pep247.py @@ -39,24 +39,24 @@ class Pep247Test(unittest.TestCase): obj3.update('string') h2 = obj3.digest() - self.assertEquals(h1, h2) + self.assertEqual(h1, h2) self.assertTrue(hasattr(obj1, 'digest_size')) if not module.digest_size is None: - self.assertEquals(obj1.digest_size, module.digest_size) + self.assertEqual(obj1.digest_size, module.digest_size) - self.assertEquals(obj1.digest_size, len(h1)) + self.assertEqual(obj1.digest_size, len(h1)) obj1.update('string') obj_copy = obj1.copy() - self.assertEquals(obj1.digest(), obj_copy.digest()) - self.assertEquals(obj1.hexdigest(), obj_copy.hexdigest()) + self.assertEqual(obj1.digest(), obj_copy.digest()) + self.assertEqual(obj1.hexdigest(), obj_copy.hexdigest()) digest, hexdigest = obj1.digest(), obj1.hexdigest() hd2 = "" for byte in digest: hd2 += '%02x' % ord(byte) - self.assertEquals(hd2, hexdigest) + self.assertEqual(hd2, hexdigest) def test_md5(self): self.check_module(md5) diff --git a/Lib/test/test_platform.py b/Lib/test/test_platform.py index ad96663..1ae5888 100644 --- a/Lib/test/test_platform.py +++ b/Lib/test/test_platform.py @@ -183,17 +183,17 @@ class PlatformTest(unittest.TestCase): # On Snow Leopard, sw_vers reports 10.6.0 as 10.6 if len_diff > 0: expect_list.extend(['0'] * len_diff) - self.assertEquals(result_list, expect_list) + self.assertEqual(result_list, expect_list) # res[1] claims to contain # (version, dev_stage, non_release_version) # That information is no longer available - self.assertEquals(res[1], ('', '', '')) + self.assertEqual(res[1], ('', '', '')) if sys.byteorder == 'little': - self.assertEquals(res[2], 'i386') + self.assertEqual(res[2], 'i386') else: - self.assertEquals(res[2], 'PowerPC') + self.assertEqual(res[2], 'PowerPC') @unittest.skipUnless(sys.platform == 'darwin', "OSX only test") @@ -211,8 +211,8 @@ class PlatformTest(unittest.TestCase): else: # parent cpid, sts = os.waitpid(pid, 0) - self.assertEquals(cpid, pid) - self.assertEquals(sts, 0) + self.assertEqual(cpid, pid) + self.assertEqual(sts, 0) def test_dist(self): res = platform.dist() diff --git a/Lib/test/test_popen2.py b/Lib/test/test_popen2.py index 715858e..ea41075 100644 --- a/Lib/test/test_popen2.py +++ b/Lib/test/test_popen2.py @@ -63,8 +63,8 @@ class Popen2Test(unittest.TestCase): w.write(teststr) w.close() got = r.read() - self.assertEquals(expected_out, got.strip(), "wrote %r read %r" % - (teststr, got)) + self.assertEqual(expected_out, got.strip(), "wrote %r read %r" % + (teststr, got)) if e is not None: got = e.read() @@ -90,7 +90,7 @@ class Popen2Test(unittest.TestCase): w, r = os.popen2(["echo", self.teststr]) got = r.read() - self.assertEquals(got, self.teststr + "\n") + self.assertEqual(got, self.teststr + "\n") w, r = os.popen2(self.cmd) self.validate_output(self.teststr, self.expected, r, w) @@ -103,7 +103,7 @@ class Popen2Test(unittest.TestCase): w, r, e = os.popen3(["echo", self.teststr]) got = r.read() - self.assertEquals(got, self.teststr + "\n") + self.assertEqual(got, self.teststr + "\n") got = e.read() self.assertFalse(got, "unexpected %r on stderr" % got) @@ -117,7 +117,7 @@ class Popen2Test(unittest.TestCase): w, r = os.popen4(["echo", self.teststr]) got = r.read() - self.assertEquals(got, self.teststr + "\n") + self.assertEqual(got, self.teststr + "\n") w, r = os.popen4(self.cmd) self.validate_output(self.teststr, self.expected, r, w) diff --git a/Lib/test/test_posix.py b/Lib/test/test_posix.py index 1119142..17cdc5b 100644 --- a/Lib/test/test_posix.py +++ b/Lib/test/test_posix.py @@ -103,7 +103,7 @@ class PosixTester(unittest.TestCase): try: posix.initgroups(name, 13) except OSError as e: - self.assertEquals(e.errno, errno.EPERM) + self.assertEqual(e.errno, errno.EPERM) else: self.fail("Expected OSError to be raised by initgroups") diff --git a/Lib/test/test_pow.py b/Lib/test/test_pow.py index 361a475..1ee67bc 100644 --- a/Lib/test/test_pow.py +++ b/Lib/test/test_pow.py @@ -5,17 +5,17 @@ class PowTest(unittest.TestCase): def powtest(self, type): if type != float: for i in range(-1000, 1000): - self.assertEquals(pow(type(i), 0), 1) - self.assertEquals(pow(type(i), 1), type(i)) - self.assertEquals(pow(type(0), 1), type(0)) - self.assertEquals(pow(type(1), 1), type(1)) + self.assertEqual(pow(type(i), 0), 1) + self.assertEqual(pow(type(i), 1), type(i)) + self.assertEqual(pow(type(0), 1), type(0)) + self.assertEqual(pow(type(1), 1), type(1)) for i in range(-100, 100): - self.assertEquals(pow(type(i), 3), i*i*i) + self.assertEqual(pow(type(i), 3), i*i*i) pow2 = 1 for i in range(0,31): - self.assertEquals(pow(2, i), pow2) + self.assertEqual(pow(2, i), pow2) if i != 30 : pow2 = pow2*2 for othertype in int, long: @@ -67,30 +67,30 @@ class PowTest(unittest.TestCase): def test_other(self): # Other tests-- not very systematic - self.assertEquals(pow(3,3) % 8, pow(3,3,8)) - self.assertEquals(pow(3,3) % -8, pow(3,3,-8)) - self.assertEquals(pow(3,2) % -2, pow(3,2,-2)) - self.assertEquals(pow(-3,3) % 8, pow(-3,3,8)) - self.assertEquals(pow(-3,3) % -8, pow(-3,3,-8)) - self.assertEquals(pow(5,2) % -8, pow(5,2,-8)) - - self.assertEquals(pow(3L,3L) % 8, pow(3L,3L,8)) - self.assertEquals(pow(3L,3L) % -8, pow(3L,3L,-8)) - self.assertEquals(pow(3L,2) % -2, pow(3L,2,-2)) - self.assertEquals(pow(-3L,3L) % 8, pow(-3L,3L,8)) - self.assertEquals(pow(-3L,3L) % -8, pow(-3L,3L,-8)) - self.assertEquals(pow(5L,2) % -8, pow(5L,2,-8)) + self.assertEqual(pow(3,3) % 8, pow(3,3,8)) + self.assertEqual(pow(3,3) % -8, pow(3,3,-8)) + self.assertEqual(pow(3,2) % -2, pow(3,2,-2)) + self.assertEqual(pow(-3,3) % 8, pow(-3,3,8)) + self.assertEqual(pow(-3,3) % -8, pow(-3,3,-8)) + self.assertEqual(pow(5,2) % -8, pow(5,2,-8)) + + self.assertEqual(pow(3L,3L) % 8, pow(3L,3L,8)) + self.assertEqual(pow(3L,3L) % -8, pow(3L,3L,-8)) + self.assertEqual(pow(3L,2) % -2, pow(3L,2,-2)) + self.assertEqual(pow(-3L,3L) % 8, pow(-3L,3L,8)) + self.assertEqual(pow(-3L,3L) % -8, pow(-3L,3L,-8)) + self.assertEqual(pow(5L,2) % -8, pow(5L,2,-8)) for i in range(-10, 11): for j in range(0, 6): for k in range(-7, 11): if j >= 0 and k != 0: - self.assertEquals( + self.assertEqual( pow(i,j) % k, pow(i,j,k) ) if j >= 0 and k != 0: - self.assertEquals( + self.assertEqual( pow(long(i),j) % k, pow(long(i),j,k) ) @@ -104,7 +104,7 @@ class PowTest(unittest.TestCase): def test_bug705231(self): # -1.0 raised to an integer should never blow up. It did if the # platform pow() was buggy, and Python didn't worm around it. - eq = self.assertEquals + eq = self.assertEqual a = -1.0 # The next two tests can still fail if the platform floor() # function doesn't treat all large inputs as integers diff --git a/Lib/test/test_pty.py b/Lib/test/test_pty.py index ddf4807..05ab598 100644 --- a/Lib/test/test_pty.py +++ b/Lib/test/test_pty.py @@ -86,7 +86,7 @@ class PtyTest(unittest.TestCase): fcntl.fcntl(master_fd, fcntl.F_SETFL, orig_flags | os.O_NONBLOCK) try: s1 = os.read(master_fd, 1024) - self.assertEquals('', s1) + self.assertEqual('', s1) except OSError, e: if e.errno != errno.EAGAIN: raise @@ -96,14 +96,14 @@ class PtyTest(unittest.TestCase): debug("Writing to slave_fd") os.write(slave_fd, TEST_STRING_1) s1 = os.read(master_fd, 1024) - self.assertEquals('I wish to buy a fish license.\n', - normalize_output(s1)) + self.assertEqual('I wish to buy a fish license.\n', + normalize_output(s1)) debug("Writing chunked output") os.write(slave_fd, TEST_STRING_2[:5]) os.write(slave_fd, TEST_STRING_2[5:]) s2 = os.read(master_fd, 1024) - self.assertEquals('For my pet fish, Eric.\n', normalize_output(s2)) + self.assertEqual('For my pet fish, Eric.\n', normalize_output(s2)) os.close(slave_fd) os.close(master_fd) diff --git a/Lib/test/test_py3kwarn.py b/Lib/test/test_py3kwarn.py index 32c36a9..2afd8a1 100644 --- a/Lib/test/test_py3kwarn.py +++ b/Lib/test/test_py3kwarn.py @@ -397,7 +397,7 @@ class TestStdlibRemovals(unittest.TestCase): reset_module_registry(mod) with check_py3k_warnings() as w: mod.walk("crashers", dumbo, None) - self.assertEquals(str(w.message), msg) + self.assertEqual(str(w.message), msg) def test_reduce_move(self): from operator import add diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py index fda76d4..6aa96d5 100644 --- a/Lib/test/test_pyclbr.py +++ b/Lib/test/test_pyclbr.py @@ -97,7 +97,7 @@ class PyclbrTest(TestCase): self.assertIsInstance(py_item, (FunctionType, BuiltinFunctionType)) if py_item.__module__ != moduleName: continue # skip functions that came from somewhere else - self.assertEquals(py_item.__module__, value.module) + self.assertEqual(py_item.__module__, value.module) else: self.assertIsInstance(py_item, (ClassType, type)) if py_item.__module__ != moduleName: @@ -126,7 +126,7 @@ class PyclbrTest(TestCase): try: self.assertListEq(foundMethods, actualMethods, ignore) - self.assertEquals(py_item.__module__, value.module) + self.assertEqual(py_item.__module__, value.module) self.assertEqualsOrIgnored(py_item.__name__, value.name, ignore) diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py index 68a1451..840a7a8 100644 --- a/Lib/test/test_pyexpat.py +++ b/Lib/test/test_pyexpat.py @@ -22,17 +22,17 @@ class SetAttributeTest(unittest.TestCase): def test_returns_unicode(self): for x, y in self.set_get_pairs: self.parser.returns_unicode = x - self.assertEquals(self.parser.returns_unicode, y) + self.assertEqual(self.parser.returns_unicode, y) def test_ordered_attributes(self): for x, y in self.set_get_pairs: self.parser.ordered_attributes = x - self.assertEquals(self.parser.ordered_attributes, y) + self.assertEqual(self.parser.ordered_attributes, y) def test_specified_attributes(self): for x, y in self.set_get_pairs: self.parser.specified_attributes = x - self.assertEquals(self.parser.specified_attributes, y) + self.assertEqual(self.parser.specified_attributes, y) data = '''\ @@ -140,23 +140,23 @@ class ParseTest(unittest.TestCase): # Verify output op = out.out - self.assertEquals(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'') - self.assertEquals(op[1], "Comment: ' comment data '") - self.assertEquals(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)") - self.assertEquals(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')") - self.assertEquals(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}") - self.assertEquals(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'") - self.assertEquals(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}") - self.assertEquals(op[7], "Character data: 'Contents of subelements'") - self.assertEquals(op[8], "End element: 'http://www.python.org/namespace!subelement'") - self.assertEquals(op[9], "End of NS decl: 'myns'") - self.assertEquals(op[10], "Start element: 'sub2' {}") - self.assertEquals(op[11], 'Start of CDATA section') - self.assertEquals(op[12], "Character data: 'contents of CDATA section'") - self.assertEquals(op[13], 'End of CDATA section') - self.assertEquals(op[14], "End element: 'sub2'") - self.assertEquals(op[15], "External entity ref: (None, 'entity.file', None)") - self.assertEquals(op[16], "End element: 'root'") + self.assertEqual(op[0], 'PI: \'xml-stylesheet\' \'href="stylesheet.css"\'') + self.assertEqual(op[1], "Comment: ' comment data '") + self.assertEqual(op[2], "Notation declared: ('notation', None, 'notation.jpeg', None)") + self.assertEqual(op[3], "Unparsed entity decl: ('unparsed_entity', None, 'entity.file', None, 'notation')") + self.assertEqual(op[4], "Start element: 'root' {'attr1': 'value1', 'attr2': 'value2\\xe1\\xbd\\x80'}") + self.assertEqual(op[5], "NS decl: 'myns' 'http://www.python.org/namespace'") + self.assertEqual(op[6], "Start element: 'http://www.python.org/namespace!subelement' {}") + self.assertEqual(op[7], "Character data: 'Contents of subelements'") + self.assertEqual(op[8], "End element: 'http://www.python.org/namespace!subelement'") + self.assertEqual(op[9], "End of NS decl: 'myns'") + self.assertEqual(op[10], "Start element: 'sub2' {}") + self.assertEqual(op[11], 'Start of CDATA section') + self.assertEqual(op[12], "Character data: 'contents of CDATA section'") + self.assertEqual(op[13], 'End of CDATA section') + self.assertEqual(op[14], "End element: 'sub2'") + self.assertEqual(op[15], "External entity ref: (None, 'entity.file', None)") + self.assertEqual(op[16], "End element: 'root'") def test_unicode(self): # Try the parse again, this time producing Unicode output @@ -169,23 +169,23 @@ class ParseTest(unittest.TestCase): parser.Parse(data, 1) op = out.out - self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') - self.assertEquals(op[1], "Comment: u' comment data '") - self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") - self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") - self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") - self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") - self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") - self.assertEquals(op[7], "Character data: u'Contents of subelements'") - self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'") - self.assertEquals(op[9], "End of NS decl: u'myns'") - self.assertEquals(op[10], "Start element: u'sub2' {}") - self.assertEquals(op[11], 'Start of CDATA section') - self.assertEquals(op[12], "Character data: u'contents of CDATA section'") - self.assertEquals(op[13], 'End of CDATA section') - self.assertEquals(op[14], "End element: u'sub2'") - self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)") - self.assertEquals(op[16], "End element: u'root'") + self.assertEqual(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') + self.assertEqual(op[1], "Comment: u' comment data '") + self.assertEqual(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") + self.assertEqual(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") + self.assertEqual(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") + self.assertEqual(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") + self.assertEqual(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") + self.assertEqual(op[7], "Character data: u'Contents of subelements'") + self.assertEqual(op[8], "End element: u'http://www.python.org/namespace!subelement'") + self.assertEqual(op[9], "End of NS decl: u'myns'") + self.assertEqual(op[10], "Start element: u'sub2' {}") + self.assertEqual(op[11], 'Start of CDATA section') + self.assertEqual(op[12], "Character data: u'contents of CDATA section'") + self.assertEqual(op[13], 'End of CDATA section') + self.assertEqual(op[14], "End element: u'sub2'") + self.assertEqual(op[15], "External entity ref: (None, u'entity.file', None)") + self.assertEqual(op[16], "End element: u'root'") def test_parse_file(self): # Try parsing a file @@ -199,23 +199,23 @@ class ParseTest(unittest.TestCase): parser.ParseFile(file) op = out.out - self.assertEquals(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') - self.assertEquals(op[1], "Comment: u' comment data '") - self.assertEquals(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") - self.assertEquals(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") - self.assertEquals(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") - self.assertEquals(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") - self.assertEquals(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") - self.assertEquals(op[7], "Character data: u'Contents of subelements'") - self.assertEquals(op[8], "End element: u'http://www.python.org/namespace!subelement'") - self.assertEquals(op[9], "End of NS decl: u'myns'") - self.assertEquals(op[10], "Start element: u'sub2' {}") - self.assertEquals(op[11], 'Start of CDATA section') - self.assertEquals(op[12], "Character data: u'contents of CDATA section'") - self.assertEquals(op[13], 'End of CDATA section') - self.assertEquals(op[14], "End element: u'sub2'") - self.assertEquals(op[15], "External entity ref: (None, u'entity.file', None)") - self.assertEquals(op[16], "End element: u'root'") + self.assertEqual(op[0], 'PI: u\'xml-stylesheet\' u\'href="stylesheet.css"\'') + self.assertEqual(op[1], "Comment: u' comment data '") + self.assertEqual(op[2], "Notation declared: (u'notation', None, u'notation.jpeg', None)") + self.assertEqual(op[3], "Unparsed entity decl: (u'unparsed_entity', None, u'entity.file', None, u'notation')") + self.assertEqual(op[4], "Start element: u'root' {u'attr1': u'value1', u'attr2': u'value2\\u1f40'}") + self.assertEqual(op[5], "NS decl: u'myns' u'http://www.python.org/namespace'") + self.assertEqual(op[6], "Start element: u'http://www.python.org/namespace!subelement' {}") + self.assertEqual(op[7], "Character data: u'Contents of subelements'") + self.assertEqual(op[8], "End element: u'http://www.python.org/namespace!subelement'") + self.assertEqual(op[9], "End of NS decl: u'myns'") + self.assertEqual(op[10], "Start element: u'sub2' {}") + self.assertEqual(op[11], 'Start of CDATA section') + self.assertEqual(op[12], "Character data: u'contents of CDATA section'") + self.assertEqual(op[13], 'End of CDATA section') + self.assertEqual(op[14], "End element: u'sub2'") + self.assertEqual(op[15], "External entity ref: (None, u'entity.file', None)") + self.assertEqual(op[16], "End element: u'root'") class NamespaceSeparatorTest(unittest.TestCase): @@ -231,14 +231,14 @@ class NamespaceSeparatorTest(unittest.TestCase): expat.ParserCreate(namespace_separator=42) self.fail() except TypeError, e: - self.assertEquals(str(e), + self.assertEqual(str(e), 'ParserCreate() argument 2 must be string or None, not int') try: expat.ParserCreate(namespace_separator='too long') self.fail() except ValueError, e: - self.assertEquals(str(e), + self.assertEqual(str(e), 'namespace_separator must be at most one character, omitted, or None') def test_zero_length(self): @@ -264,7 +264,7 @@ class InterningTest(unittest.TestCase): p.EndElementHandler = collector p.Parse(" ", 1) tag = L[0] - self.assertEquals(len(L), 6) + self.assertEqual(len(L), 6) for entry in L: # L should have the same string repeated over and over. self.assertTrue(tag is entry) @@ -278,7 +278,7 @@ class BufferTextTest(unittest.TestCase): self.parser.CharacterDataHandler = self.CharacterDataHandler def check(self, expected, label): - self.assertEquals(self.stuff, expected, + self.assertEqual(self.stuff, expected, "%s\nstuff = %r\nexpected = %r" % (label, self.stuff, map(unicode, expected))) @@ -311,47 +311,47 @@ class BufferTextTest(unittest.TestCase): # Make sure buffering is turned on self.assertTrue(self.parser.buffer_text) self.parser.Parse("123", 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("12\n34\n5", 1) - self.assertEquals(self.stuff, - ["", "1", "", "2", "\n", "3", "", "4\n5"], - "buffering control not reacting as expected") + self.assertEqual(self.stuff, + ["", "1", "", "2", "\n", "3", "", "4\n5"], + "buffering control not reacting as expected") def test2(self): self.parser.Parse("1<2> \n 3", 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("123", 1) - self.assertEquals(self.stuff, ["", "1", "", "2", "", "3"], + self.assertEqual(self.stuff, ["", "1", "", "2", "", "3"], "buffered text not properly split") def test4(self): self.setHandlers(["StartElementHandler", "EndElementHandler"]) self.parser.CharacterDataHandler = None self.parser.Parse("123", 1) - self.assertEquals(self.stuff, - ["", "", "", "", "", ""]) + self.assertEqual(self.stuff, + ["", "", "", "", "", ""]) def test5(self): self.setHandlers(["StartElementHandler", "EndElementHandler"]) self.parser.Parse("123", 1) - self.assertEquals(self.stuff, + self.assertEqual(self.stuff, ["", "1", "", "", "2", "", "", "3", ""]) def test6(self): self.setHandlers(["CommentHandler", "EndElementHandler", "StartElementHandler"]) self.parser.Parse("12345 ", 1) - self.assertEquals(self.stuff, + self.assertEqual(self.stuff, ["", "1", "", "", "2", "", "", "345", ""], "buffered text not properly split") @@ -359,10 +359,10 @@ class BufferTextTest(unittest.TestCase): self.setHandlers(["CommentHandler", "EndElementHandler", "StartElementHandler"]) self.parser.Parse("12345 ", 1) - self.assertEquals(self.stuff, - ["", "1", "", "", "2", "", "", "3", - "", "4", "", "5", ""], - "buffered text not properly split") + self.assertEqual(self.stuff, + ["", "1", "", "", "2", "", "", "3", + "", "4", "", "5", ""], + "buffered text not properly split") # Test handling of exception from callback: @@ -377,9 +377,9 @@ class HandlerExceptionTest(unittest.TestCase): parser.Parse("", 1) self.fail() except RuntimeError, e: - self.assertEquals(e.args[0], 'a', - "Expected RuntimeError for element 'a', but" + \ - " found %r" % e.args[0]) + self.assertEqual(e.args[0], 'a', + "Expected RuntimeError for element 'a', but" + \ + " found %r" % e.args[0]) # Test Current* members: @@ -398,7 +398,7 @@ class PositionTest(unittest.TestCase): self.assertTrue(self.upto < len(self.expected_list), 'too many parser events') expected = self.expected_list[self.upto] - self.assertEquals(pos, expected, + self.assertEqual(pos, expected, 'Expected position %s, got position %s' %(pos, expected)) self.upto += 1 @@ -439,10 +439,10 @@ class ChardataBufferTest(unittest.TestCase): """ def test_1025_bytes(self): - self.assertEquals(self.small_buffer_test(1025), 2) + self.assertEqual(self.small_buffer_test(1025), 2) def test_1000_bytes(self): - self.assertEquals(self.small_buffer_test(1000), 1) + self.assertEqual(self.small_buffer_test(1000), 1) def test_wrong_size(self): parser = expat.ParserCreate() @@ -466,15 +466,15 @@ class ChardataBufferTest(unittest.TestCase): # once. self.n = 0 parser.Parse(xml1) - self.assertEquals(self.n, 1) + self.assertEqual(self.n, 1) # Reassign to buffer_size, but assign the same size. parser.buffer_size = parser.buffer_size - self.assertEquals(self.n, 1) + self.assertEqual(self.n, 1) # Try parsing rest of the document parser.Parse(xml2) - self.assertEquals(self.n, 2) + self.assertEqual(self.n, 2) def test_disabling_buffer(self): @@ -485,27 +485,27 @@ class ChardataBufferTest(unittest.TestCase): parser.CharacterDataHandler = self.counting_handler parser.buffer_text = 1 parser.buffer_size = 1024 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) # Parse one chunk of XML self.n = 0 parser.Parse(xml1, 0) - self.assertEquals(parser.buffer_size, 1024) - self.assertEquals(self.n, 1) + self.assertEqual(parser.buffer_size, 1024) + self.assertEqual(self.n, 1) # Turn off buffering and parse the next chunk. parser.buffer_text = 0 self.assertFalse(parser.buffer_text) - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) for i in range(10): parser.Parse(xml2, 0) - self.assertEquals(self.n, 11) + self.assertEqual(self.n, 11) parser.buffer_text = 1 self.assertTrue(parser.buffer_text) - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) parser.Parse(xml3, 1) - self.assertEquals(self.n, 12) + self.assertEqual(self.n, 12) @@ -533,14 +533,14 @@ class ChardataBufferTest(unittest.TestCase): parser.CharacterDataHandler = self.counting_handler parser.buffer_text = 1 parser.buffer_size = 1024 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) self.n = 0 parser.Parse(xml1, 0) parser.buffer_size *= 2 - self.assertEquals(parser.buffer_size, 2048) + self.assertEqual(parser.buffer_size, 2048) parser.Parse(xml2, 1) - self.assertEquals(self.n, 2) + self.assertEqual(self.n, 2) def test_change_size_2(self): xml1 = "a%s" % ('a' * 1023) @@ -549,14 +549,14 @@ class ChardataBufferTest(unittest.TestCase): parser.CharacterDataHandler = self.counting_handler parser.buffer_text = 1 parser.buffer_size = 2048 - self.assertEquals(parser.buffer_size, 2048) + self.assertEqual(parser.buffer_size, 2048) self.n=0 parser.Parse(xml1, 0) parser.buffer_size //= 2 - self.assertEquals(parser.buffer_size, 1024) + self.assertEqual(parser.buffer_size, 1024) parser.Parse(xml2, 1) - self.assertEquals(self.n, 4) + self.assertEqual(self.n, 4) class MalformedInputText(unittest.TestCase): def test1(self): @@ -566,7 +566,7 @@ class MalformedInputText(unittest.TestCase): parser.Parse(xml, True) self.fail() except expat.ExpatError as e: - self.assertEquals(str(e), 'unclosed token: line 2, column 0') + self.assertEqual(str(e), 'unclosed token: line 2, column 0') def test2(self): xml = "\r\n" @@ -575,7 +575,7 @@ class MalformedInputText(unittest.TestCase): parser.Parse(xml, True) self.fail() except expat.ExpatError as e: - self.assertEquals(str(e), 'XML declaration not well-formed: line 1, column 14') + self.assertEqual(str(e), 'XML declaration not well-formed: line 1, column 14') def test_main(): run_unittest(SetAttributeTest, diff --git a/Lib/test/test_queue.py b/Lib/test/test_queue.py index 5f5a6ac..0b38e7e 100644 --- a/Lib/test/test_queue.py +++ b/Lib/test/test_queue.py @@ -95,8 +95,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): LifoQueue = [222, 333, 111], PriorityQueue = [111, 222, 333]) actual_order = [q.get(), q.get(), q.get()] - self.assertEquals(actual_order, target_order[q.__class__.__name__], - "Didn't seem to queue the correct data!") + self.assertEqual(actual_order, target_order[q.__class__.__name__], + "Didn't seem to queue the correct data!") for i in range(QUEUE_SIZE-1): q.put(i) self.assertTrue(not q.empty(), "Queue should not be empty") @@ -154,8 +154,8 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin): for i in xrange(100): q.put(i) q.join() - self.assertEquals(self.cum, sum(range(100)), - "q.join() did not block until all tasks were done") + self.assertEqual(self.cum, sum(range(100)), + "q.join() did not block until all tasks were done") for i in (0,1): q.put(None) # instruct the threads to close q.join() # verify that you can join twice diff --git a/Lib/test/test_repr.py b/Lib/test/test_repr.py index a8202ee..8b20acd 100644 --- a/Lib/test/test_repr.py +++ b/Lib/test/test_repr.py @@ -22,7 +22,7 @@ def nestedTuple(nesting): class ReprTests(unittest.TestCase): def test_string(self): - eq = self.assertEquals + eq = self.assertEqual eq(r("abc"), "'abc'") eq(r("abcdefghijklmnop"),"'abcdefghijklmnop'") @@ -36,7 +36,7 @@ class ReprTests(unittest.TestCase): eq(r(s), expected) def test_tuple(self): - eq = self.assertEquals + eq = self.assertEqual eq(r((1,)), "(1,)") t3 = (1, 2, 3) @@ -51,7 +51,7 @@ class ReprTests(unittest.TestCase): from array import array from collections import deque - eq = self.assertEquals + eq = self.assertEqual # Tuples give up after 6 elements eq(r(()), "()") eq(r((1,)), "(1,)") @@ -101,7 +101,7 @@ class ReprTests(unittest.TestCase): "array('i', [1, 2, 3, 4, 5, ...])") def test_numbers(self): - eq = self.assertEquals + eq = self.assertEqual eq(r(123), repr(123)) eq(r(123L), repr(123L)) eq(r(1.0/3), repr(1.0/3)) @@ -111,7 +111,7 @@ class ReprTests(unittest.TestCase): eq(r(n), expected) def test_instance(self): - eq = self.assertEquals + eq = self.assertEqual i1 = ClassWithRepr("a") eq(r(i1), repr(i1)) @@ -141,7 +141,7 @@ class ReprTests(unittest.TestCase): # XXX anonymous functions? see func_repr def test_builtin_function(self): - eq = self.assertEquals + eq = self.assertEqual # Functions eq(repr(hash), '') # Methods @@ -149,13 +149,13 @@ class ReprTests(unittest.TestCase): '") # XXX member descriptors @@ -244,7 +244,7 @@ class LongReprTest(unittest.TestCase): del sys.path[0] def test_module(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, self.pkgname + os.extsep + 'py')) from areallylongpackageandmodulenametotestreprtruncation.areallylongpackageandmodulenametotestreprtruncation import areallylongpackageandmodulenametotestreprtruncation eq(repr(areallylongpackageandmodulenametotestreprtruncation), @@ -252,7 +252,7 @@ class LongReprTest(unittest.TestCase): eq(repr(sys), "") def test_type(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'foo'+os.extsep+'py'), '''\ class foo(object): pass @@ -287,7 +287,7 @@ class baz: "<%s.baz instance at 0x" % baz.__name__)) def test_method(self): - eq = self.assertEquals + eq = self.assertEqual touch(os.path.join(self.subpkgname, 'qux'+os.extsep+'py'), '''\ class aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa: def amethod(self): pass diff --git a/Lib/test/test_sax.py b/Lib/test/test_sax.py index 2280058..adb9305 100644 --- a/Lib/test/test_sax.py +++ b/Lib/test/test_sax.py @@ -29,16 +29,16 @@ class XmlTestBase(unittest.TestCase): self.assertRaises(KeyError, attrs.getNameByQName, "attr") self.assertRaises(KeyError, attrs.getQNameByName, "attr") self.assertRaises(KeyError, attrs.__getitem__, "attr") - self.assertEquals(attrs.getLength(), 0) - self.assertEquals(attrs.getNames(), []) - self.assertEquals(attrs.getQNames(), []) - self.assertEquals(len(attrs), 0) + self.assertEqual(attrs.getLength(), 0) + self.assertEqual(attrs.getNames(), []) + self.assertEqual(attrs.getQNames(), []) + self.assertEqual(len(attrs), 0) self.assertFalse(attrs.has_key("attr")) - self.assertEquals(attrs.keys(), []) - self.assertEquals(attrs.get("attrs"), None) - self.assertEquals(attrs.get("attrs", 25), 25) - self.assertEquals(attrs.items(), []) - self.assertEquals(attrs.values(), []) + self.assertEqual(attrs.keys(), []) + self.assertEqual(attrs.get("attrs"), None) + self.assertEqual(attrs.get("attrs", 25), 25) + self.assertEqual(attrs.items(), []) + self.assertEqual(attrs.values(), []) def verify_empty_nsattrs(self, attrs): self.assertRaises(KeyError, attrs.getValue, (ns_uri, "attr")) @@ -46,33 +46,33 @@ class XmlTestBase(unittest.TestCase): self.assertRaises(KeyError, attrs.getNameByQName, "ns:attr") self.assertRaises(KeyError, attrs.getQNameByName, (ns_uri, "attr")) self.assertRaises(KeyError, attrs.__getitem__, (ns_uri, "attr")) - self.assertEquals(attrs.getLength(), 0) - self.assertEquals(attrs.getNames(), []) - self.assertEquals(attrs.getQNames(), []) - self.assertEquals(len(attrs), 0) + self.assertEqual(attrs.getLength(), 0) + self.assertEqual(attrs.getNames(), []) + self.assertEqual(attrs.getQNames(), []) + self.assertEqual(len(attrs), 0) self.assertFalse(attrs.has_key((ns_uri, "attr"))) - self.assertEquals(attrs.keys(), []) - self.assertEquals(attrs.get((ns_uri, "attr")), None) - self.assertEquals(attrs.get((ns_uri, "attr"), 25), 25) - self.assertEquals(attrs.items(), []) - self.assertEquals(attrs.values(), []) + self.assertEqual(attrs.keys(), []) + self.assertEqual(attrs.get((ns_uri, "attr")), None) + self.assertEqual(attrs.get((ns_uri, "attr"), 25), 25) + self.assertEqual(attrs.items(), []) + self.assertEqual(attrs.values(), []) def verify_attrs_wattr(self, attrs): - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), ["attr"]) - self.assertEquals(attrs.getQNames(), ["attr"]) - self.assertEquals(len(attrs), 1) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), ["attr"]) + self.assertEqual(attrs.getQNames(), ["attr"]) + self.assertEqual(len(attrs), 1) self.assertTrue(attrs.has_key("attr")) - self.assertEquals(attrs.keys(), ["attr"]) - self.assertEquals(attrs.get("attr"), "val") - self.assertEquals(attrs.get("attr", 25), "val") - self.assertEquals(attrs.items(), [("attr", "val")]) - self.assertEquals(attrs.values(), ["val"]) - self.assertEquals(attrs.getValue("attr"), "val") - self.assertEquals(attrs.getValueByQName("attr"), "val") - self.assertEquals(attrs.getNameByQName("attr"), "attr") - self.assertEquals(attrs["attr"], "val") - self.assertEquals(attrs.getQNameByName("attr"), "attr") + self.assertEqual(attrs.keys(), ["attr"]) + self.assertEqual(attrs.get("attr"), "val") + self.assertEqual(attrs.get("attr", 25), "val") + self.assertEqual(attrs.items(), [("attr", "val")]) + self.assertEqual(attrs.values(), ["val"]) + self.assertEqual(attrs.getValue("attr"), "val") + self.assertEqual(attrs.getValueByQName("attr"), "val") + self.assertEqual(attrs.getNameByQName("attr"), "attr") + self.assertEqual(attrs["attr"], "val") + self.assertEqual(attrs.getQNameByName("attr"), "attr") class MakeParserTest(unittest.TestCase): def test_make_parser2(self): @@ -102,47 +102,47 @@ class MakeParserTest(unittest.TestCase): class SaxutilsTest(unittest.TestCase): # ===== escape def test_escape_basic(self): - self.assertEquals(escape("Donald Duck & Co"), "Donald Duck & Co") + self.assertEqual(escape("Donald Duck & Co"), "Donald Duck & Co") def test_escape_all(self): - self.assertEquals(escape(""), - "<Donald Duck & Co>") + self.assertEqual(escape(""), + "<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>"), - "") + self.assertEqual(unescape("<Donald Duck & Co>"), + "") def test_unescape_extra(self): - self.assertEquals(unescape("Hei på deg", {"å" : "å"}), - "Hei på deg") + self.assertEqual(unescape("Hei på deg", {"å" : "å"}), + "Hei på deg") def test_unescape_amp_extra(self): - self.assertEquals(unescape("&foo;", {"&foo;": "splat"}), "&foo;") + self.assertEqual(unescape("&foo;", {"&foo;": "splat"}), "&foo;") # ===== quoteattr def test_quoteattr_basic(self): - self.assertEquals(quoteattr("Donald Duck & Co"), - '"Donald Duck & Co"') + self.assertEqual(quoteattr("Donald Duck & Co"), + '"Donald Duck & Co"') def test_single_quoteattr(self): - self.assertEquals(quoteattr('Includes "double" quotes'), - '\'Includes "double" quotes\'') + self.assertEqual(quoteattr('Includes "double" quotes'), + '\'Includes "double" quotes\'') def test_double_quoteattr(self): - self.assertEquals(quoteattr("Includes 'single' quotes"), - "\"Includes 'single' quotes\"") + self.assertEqual(quoteattr("Includes 'single' quotes"), + "\"Includes 'single' quotes\"") def test_single_double_quoteattr(self): - self.assertEquals(quoteattr("Includes 'single' and \"double\" quotes"), - "\"Includes 'single' and "double" quotes\"") + self.assertEqual(quoteattr("Includes 'single' and \"double\" quotes"), + "\"Includes 'single' and "double" quotes\"") # ===== make_parser def test_make_parser(self): @@ -164,7 +164,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "") + self.assertEqual(result.getvalue(), start + "") def test_xmlgen_content(self): result = StringIO() @@ -176,7 +176,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "huhei") + self.assertEqual(result.getvalue(), start + "huhei") def test_xmlgen_pi(self): result = StringIO() @@ -188,7 +188,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + "") + self.assertEqual(result.getvalue(), start + "") def test_xmlgen_content_escape(self): result = StringIO() @@ -200,7 +200,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), + self.assertEqual(result.getvalue(), start + "<huhei&") def test_xmlgen_attr_escape(self): @@ -218,7 +218,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + + self.assertEqual(result.getvalue(), start + ("" "" "")) @@ -233,7 +233,7 @@ class XmlgenTest(unittest.TestCase): gen.endElement("doc") gen.endDocument() - self.assertEquals(result.getvalue(), start + " ") + self.assertEqual(result.getvalue(), start + " ") def test_xmlgen_ns(self): result = StringIO() @@ -249,7 +249,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping("ns1") gen.endDocument() - self.assertEquals(result.getvalue(), start + \ + self.assertEqual(result.getvalue(), start + \ ('' % ns_uri)) @@ -262,7 +262,7 @@ class XmlgenTest(unittest.TestCase): gen.endElementNS((None, 'a'), 'a') gen.endDocument() - self.assertEquals(result.getvalue(), start+'') + self.assertEqual(result.getvalue(), start+'') def test_1463026_2(self): result = StringIO() @@ -275,7 +275,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping(None) gen.endDocument() - self.assertEquals(result.getvalue(), start+'') + self.assertEqual(result.getvalue(), start+'') def test_1463026_3(self): result = StringIO() @@ -288,7 +288,7 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping('my') gen.endDocument() - self.assertEquals(result.getvalue(), + self.assertEqual(result.getvalue(), start+'') def test_5027_1(self): @@ -311,11 +311,11 @@ class XmlgenTest(unittest.TestCase): parser.setContentHandler(gen) parser.parse(test_xml) - self.assertEquals(result.getvalue(), - start + ( - '' - 'Hello' - '')) + self.assertEqual(result.getvalue(), + start + ( + '' + 'Hello' + '')) def test_5027_2(self): # The xml prefix (as in xml:lang below) is reserved and bound by @@ -339,11 +339,11 @@ class XmlgenTest(unittest.TestCase): gen.endPrefixMapping('a') gen.endDocument() - self.assertEquals(result.getvalue(), - start + ( - '' - 'Hello' - '')) + self.assertEqual(result.getvalue(), + start + ( + '' + 'Hello' + '')) class XMLFilterBaseTest(unittest.TestCase): @@ -360,7 +360,7 @@ class XMLFilterBaseTest(unittest.TestCase): filter.endElement("doc") filter.endDocument() - self.assertEquals(result.getvalue(), start + "content ") + self.assertEqual(result.getvalue(), start + "content ") # =========================================================================== # @@ -382,7 +382,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(open(TEST_XMLFILE)) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== DTDHandler support @@ -410,9 +410,9 @@ class ExpatReaderTest(XmlTestBase): parser.feed('') parser.close() - self.assertEquals(handler._notations, + self.assertEqual(handler._notations, [("GIF", "-//CompuServe//NOTATION Graphics Interchange Format 89a//EN", None)]) - self.assertEquals(handler._entities, [("img", None, "expat.gif", "GIF")]) + self.assertEqual(handler._entities, [("img", None, "expat.gif", "GIF")]) # ===== EntityResolver support @@ -435,8 +435,8 @@ class ExpatReaderTest(XmlTestBase): parser.feed('&test;') parser.close() - self.assertEquals(result.getvalue(), start + - "") + self.assertEqual(result.getvalue(), start + + "") # ===== Attributes support @@ -488,18 +488,18 @@ class ExpatReaderTest(XmlTestBase): attrs = gather._attrs - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), [(ns_uri, "attr")]) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), [(ns_uri, "attr")]) self.assertTrue((attrs.getQNames() == [] or attrs.getQNames() == ["ns:attr"])) - self.assertEquals(len(attrs), 1) + self.assertEqual(len(attrs), 1) self.assertTrue(attrs.has_key((ns_uri, "attr"))) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")]) - self.assertEquals(attrs.values(), ["val"]) - self.assertEquals(attrs.getValue((ns_uri, "attr")), "val") - self.assertEquals(attrs[(ns_uri, "attr")], "val") + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(attrs.items(), [((ns_uri, "attr"), "val")]) + self.assertEqual(attrs.values(), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs[(ns_uri, "attr")], "val") # ===== InputSource support @@ -511,7 +511,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(TEST_XMLFILE) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_sysid(self): parser = create_parser() @@ -521,7 +521,7 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(InputSource(TEST_XMLFILE)) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) def test_expat_inpsource_stream(self): parser = create_parser() @@ -533,7 +533,7 @@ class ExpatReaderTest(XmlTestBase): inpsrc.setByteStream(open(TEST_XMLFILE)) parser.parse(inpsrc) - self.assertEquals(result.getvalue(), xml_test_out) + self.assertEqual(result.getvalue(), xml_test_out) # ===== IncrementalParser support @@ -547,7 +547,7 @@ class ExpatReaderTest(XmlTestBase): parser.feed("") parser.close() - self.assertEquals(result.getvalue(), start + "") + self.assertEqual(result.getvalue(), start + "") def test_expat_incremental_reset(self): result = StringIO() @@ -568,7 +568,7 @@ class ExpatReaderTest(XmlTestBase): parser.feed("") parser.close() - self.assertEquals(result.getvalue(), start + "text") + self.assertEqual(result.getvalue(), start + "text") # ===== Locator support @@ -582,9 +582,9 @@ class ExpatReaderTest(XmlTestBase): parser.feed("") parser.close() - self.assertEquals(parser.getSystemId(), None) - self.assertEquals(parser.getPublicId(), None) - self.assertEquals(parser.getLineNumber(), 1) + self.assertEqual(parser.getSystemId(), None) + self.assertEqual(parser.getPublicId(), None) + self.assertEqual(parser.getLineNumber(), 1) def test_expat_locator_withinfo(self): result = StringIO() @@ -593,8 +593,8 @@ class ExpatReaderTest(XmlTestBase): parser.setContentHandler(xmlgen) parser.parse(TEST_XMLFILE) - self.assertEquals(parser.getSystemId(), TEST_XMLFILE) - self.assertEquals(parser.getPublicId(), None) + self.assertEqual(parser.getSystemId(), TEST_XMLFILE) + self.assertEqual(parser.getPublicId(), None) # =========================================================================== @@ -615,7 +615,7 @@ class ErrorReportingTest(unittest.TestCase): parser.parse(source) self.fail() except SAXException, e: - self.assertEquals(e.getSystemId(), name) + self.assertEqual(e.getSystemId(), name) def test_expat_incomplete(self): parser = create_parser() @@ -679,21 +679,21 @@ class XmlReaderTest(XmlTestBase): attrs = AttributesNSImpl({(ns_uri, "attr") : "val"}, {(ns_uri, "attr") : "ns:attr"}) - self.assertEquals(attrs.getLength(), 1) - self.assertEquals(attrs.getNames(), [(ns_uri, "attr")]) - self.assertEquals(attrs.getQNames(), ["ns:attr"]) - self.assertEquals(len(attrs), 1) + self.assertEqual(attrs.getLength(), 1) + self.assertEqual(attrs.getNames(), [(ns_uri, "attr")]) + self.assertEqual(attrs.getQNames(), ["ns:attr"]) + self.assertEqual(len(attrs), 1) self.assertTrue(attrs.has_key((ns_uri, "attr"))) - self.assertEquals(attrs.keys(), [(ns_uri, "attr")]) - self.assertEquals(attrs.get((ns_uri, "attr")), "val") - self.assertEquals(attrs.get((ns_uri, "attr"), 25), "val") - self.assertEquals(attrs.items(), [((ns_uri, "attr"), "val")]) - self.assertEquals(attrs.values(), ["val"]) - self.assertEquals(attrs.getValue((ns_uri, "attr")), "val") - self.assertEquals(attrs.getValueByQName("ns:attr"), "val") - self.assertEquals(attrs.getNameByQName("ns:attr"), (ns_uri, "attr")) - self.assertEquals(attrs[(ns_uri, "attr")], "val") - self.assertEquals(attrs.getQNameByName((ns_uri, "attr")), "ns:attr") + self.assertEqual(attrs.keys(), [(ns_uri, "attr")]) + self.assertEqual(attrs.get((ns_uri, "attr")), "val") + self.assertEqual(attrs.get((ns_uri, "attr"), 25), "val") + self.assertEqual(attrs.items(), [((ns_uri, "attr"), "val")]) + self.assertEqual(attrs.values(), ["val"]) + self.assertEqual(attrs.getValue((ns_uri, "attr")), "val") + self.assertEqual(attrs.getValueByQName("ns:attr"), "val") + self.assertEqual(attrs.getNameByQName("ns:attr"), (ns_uri, "attr")) + self.assertEqual(attrs[(ns_uri, "attr")], "val") + self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr") # During the development of Python 2.5, an attempt to move the "xml" @@ -729,7 +729,7 @@ class XmlReaderTest(XmlTestBase): try: import xml.sax.expatreader module = xml.sax.expatreader - self.assertEquals(module.__name__, "xml.sax.expatreader") + self.assertEqual(module.__name__, "xml.sax.expatreader") finally: sys.modules.update(old_modules) diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py index ab9e812..94583e1 100644 --- a/Lib/test/test_scope.py +++ b/Lib/test/test_scope.py @@ -523,7 +523,7 @@ self.assertTrue(X.passed) def f(self): return x - self.assertEquals(x, 12) # Used to raise UnboundLocalError + self.assertEqual(x, 12) # Used to raise UnboundLocalError finally: sys.settrace(None) diff --git a/Lib/test/test_shutil.py b/Lib/test/test_shutil.py index 9f14fd8..fdc0bc1 100644 --- a/Lib/test/test_shutil.py +++ b/Lib/test/test_shutil.py @@ -431,7 +431,7 @@ class TestShutil(unittest.TestCase): self.assertTrue(os.path.exists(tarball2)) # let's compare both tarballs - self.assertEquals(self._tarinfo(tarball), self._tarinfo(tarball2)) + self.assertEqual(self._tarinfo(tarball), self._tarinfo(tarball2)) # trying an uncompressed one base_name = os.path.join(tmpdir2, 'archive') @@ -525,8 +525,8 @@ class TestShutil(unittest.TestCase): archive = tarfile.open(archive_name) try: for member in archive.getmembers(): - self.assertEquals(member.uid, 0) - self.assertEquals(member.gid, 0) + self.assertEqual(member.uid, 0) + self.assertEqual(member.gid, 0) finally: archive.close() @@ -541,7 +541,7 @@ class TestShutil(unittest.TestCase): make_archive('xxx', 'xxx', root_dir=self.mkdtemp()) except Exception: pass - self.assertEquals(os.getcwd(), current_dir) + self.assertEqual(os.getcwd(), current_dir) finally: unregister_archive_format('xxx') diff --git a/Lib/test/test_signal.py b/Lib/test/test_signal.py index a703817..8feb145 100644 --- a/Lib/test/test_signal.py +++ b/Lib/test/test_signal.py @@ -203,10 +203,10 @@ class BasicSignalTests(unittest.TestCase): def test_getsignal(self): hup = signal.signal(signal.SIGHUP, self.trivial_signal_handler) - self.assertEquals(signal.getsignal(signal.SIGHUP), - self.trivial_signal_handler) + self.assertEqual(signal.getsignal(signal.SIGHUP), + self.trivial_signal_handler) signal.signal(signal.SIGHUP, hup) - self.assertEquals(signal.getsignal(signal.SIGHUP), hup) + self.assertEqual(signal.getsignal(signal.SIGHUP), hup) @unittest.skipUnless(sys.platform == "win32", "Windows specific") @@ -456,9 +456,9 @@ class ItimerTest(unittest.TestCase): "high") # virtual itimer should be (0.0, 0.0) now - self.assertEquals(signal.getitimer(self.itimer), (0.0, 0.0)) + self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0)) # and the handler should have been called - self.assertEquals(self.hndl_called, True) + self.assertEqual(self.hndl_called, True) # Issue 3864. Unknown if this affects earlier versions of freebsd also. @unittest.skipIf(sys.platform=='freebsd6', @@ -479,7 +479,7 @@ class ItimerTest(unittest.TestCase): "high") # profiling itimer should be (0.0, 0.0) now - self.assertEquals(signal.getitimer(self.itimer), (0.0, 0.0)) + self.assertEqual(signal.getitimer(self.itimer), (0.0, 0.0)) # and the handler should have been called self.assertEqual(self.hndl_called, True) diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py index 14d5ca0..4e801e9 100644 --- a/Lib/test/test_site.py +++ b/Lib/test/test_site.py @@ -139,7 +139,7 @@ class HelperFunctionsTests(unittest.TestCase): user_base = site.getuserbase() # the call sets site.USER_BASE - self.assertEquals(site.USER_BASE, user_base) + self.assertEqual(site.USER_BASE, user_base) # let's set PYTHONUSERBASE and see if it uses it site.USER_BASE = None @@ -157,7 +157,7 @@ class HelperFunctionsTests(unittest.TestCase): user_site = site.getusersitepackages() # the call sets USER_BASE *and* USER_SITE - self.assertEquals(site.USER_SITE, user_site) + self.assertEqual(site.USER_SITE, user_site) self.assertTrue(user_site.startswith(site.USER_BASE), user_site) def test_getsitepackages(self): @@ -167,19 +167,19 @@ class HelperFunctionsTests(unittest.TestCase): if sys.platform in ('os2emx', 'riscos'): self.assertEqual(len(dirs), 1) wanted = os.path.join('xoxo', 'Lib', 'site-packages') - self.assertEquals(dirs[0], wanted) + self.assertEqual(dirs[0], wanted) elif os.sep == '/': self.assertEqual(len(dirs), 2) wanted = os.path.join('xoxo', 'lib', 'python' + sys.version[:3], 'site-packages') - self.assertEquals(dirs[0], wanted) + self.assertEqual(dirs[0], wanted) wanted = os.path.join('xoxo', 'lib', 'site-python') - self.assertEquals(dirs[1], wanted) + self.assertEqual(dirs[1], wanted) else: self.assertEqual(len(dirs), 2) - self.assertEquals(dirs[0], 'xoxo') + self.assertEqual(dirs[0], 'xoxo') wanted = os.path.join('xoxo', 'lib', 'site-packages') - self.assertEquals(dirs[1], wanted) + self.assertEqual(dirs[1], wanted) # let's try the specific Apple location if (sys.platform == "darwin" and @@ -189,10 +189,10 @@ class HelperFunctionsTests(unittest.TestCase): self.assertEqual(len(dirs), 4) wanted = os.path.join('~', 'Library', 'Python', sys.version[:3], 'site-packages') - self.assertEquals(dirs[2], os.path.expanduser(wanted)) + self.assertEqual(dirs[2], os.path.expanduser(wanted)) wanted = os.path.join('/Library', 'Python', sys.version[:3], 'site-packages') - self.assertEquals(dirs[3], wanted) + self.assertEqual(dirs[3], wanted) class PthFile(object): """Helper class for handling testing of .pth files""" diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py index b9208e7..3304d6b 100644 --- a/Lib/test/test_slice.py +++ b/Lib/test/test_slice.py @@ -117,7 +117,7 @@ class SliceTest(unittest.TestCase): x = X() with test_support.check_py3k_warnings(): x[1:2] = 42 - self.assertEquals(tmp, [(1, 2, 42)]) + self.assertEqual(tmp, [(1, 2, 42)]) def test_pickle(self): s = slice(10, 20, 3) diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py index a3c1d98..0cf57bd 100644 --- a/Lib/test/test_socket.py +++ b/Lib/test/test_socket.py @@ -425,8 +425,8 @@ class GeneralModuleTests(unittest.TestCase): return # No inet_aton, nothing to check # Test that issue1008086 and issue767150 are fixed. # It must return 4 bytes. - self.assertEquals('\x00'*4, socket.inet_aton('0.0.0.0')) - self.assertEquals('\xff'*4, socket.inet_aton('255.255.255.255')) + self.assertEqual('\x00'*4, socket.inet_aton('0.0.0.0')) + self.assertEqual('\xff'*4, socket.inet_aton('255.255.255.255')) def testIPv4toString(self): if not hasattr(socket, 'inet_pton'): @@ -434,16 +434,16 @@ class GeneralModuleTests(unittest.TestCase): from socket import inet_aton as f, inet_pton, AF_INET g = lambda a: inet_pton(AF_INET, a) - self.assertEquals('\x00\x00\x00\x00', f('0.0.0.0')) - self.assertEquals('\xff\x00\xff\x00', f('255.0.255.0')) - self.assertEquals('\xaa\xaa\xaa\xaa', f('170.170.170.170')) - self.assertEquals('\x01\x02\x03\x04', f('1.2.3.4')) - self.assertEquals('\xff\xff\xff\xff', f('255.255.255.255')) + self.assertEqual('\x00\x00\x00\x00', f('0.0.0.0')) + self.assertEqual('\xff\x00\xff\x00', f('255.0.255.0')) + self.assertEqual('\xaa\xaa\xaa\xaa', f('170.170.170.170')) + self.assertEqual('\x01\x02\x03\x04', f('1.2.3.4')) + self.assertEqual('\xff\xff\xff\xff', f('255.255.255.255')) - self.assertEquals('\x00\x00\x00\x00', g('0.0.0.0')) - self.assertEquals('\xff\x00\xff\x00', g('255.0.255.0')) - self.assertEquals('\xaa\xaa\xaa\xaa', g('170.170.170.170')) - self.assertEquals('\xff\xff\xff\xff', g('255.255.255.255')) + self.assertEqual('\x00\x00\x00\x00', g('0.0.0.0')) + self.assertEqual('\xff\x00\xff\x00', g('255.0.255.0')) + self.assertEqual('\xaa\xaa\xaa\xaa', g('170.170.170.170')) + self.assertEqual('\xff\xff\xff\xff', g('255.255.255.255')) def testIPv6toString(self): if not hasattr(socket, 'inet_pton'): @@ -456,10 +456,10 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_pton(AF_INET6, a) - self.assertEquals('\x00' * 16, f('::')) - self.assertEquals('\x00' * 16, f('0::0')) - self.assertEquals('\x00\x01' + '\x00' * 14, f('1::')) - self.assertEquals( + self.assertEqual('\x00' * 16, f('::')) + self.assertEqual('\x00' * 16, f('0::0')) + self.assertEqual('\x00\x01' + '\x00' * 14, f('1::')) + self.assertEqual( '\x45\xef\x76\xcb\x00\x1a\x56\xef\xaf\xeb\x0b\xac\x19\x24\xae\xae', f('45ef:76cb:1a:56ef:afeb:bac:1924:aeae') ) @@ -470,14 +470,14 @@ class GeneralModuleTests(unittest.TestCase): from socket import inet_ntoa as f, inet_ntop, AF_INET g = lambda a: inet_ntop(AF_INET, a) - self.assertEquals('1.0.1.0', f('\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', f('\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', f('\xff\xff\xff\xff')) - self.assertEquals('1.2.3.4', f('\x01\x02\x03\x04')) + self.assertEqual('1.0.1.0', f('\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', f('\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', f('\xff\xff\xff\xff')) + self.assertEqual('1.2.3.4', f('\x01\x02\x03\x04')) - self.assertEquals('1.0.1.0', g('\x01\x00\x01\x00')) - self.assertEquals('170.85.170.85', g('\xaa\x55\xaa\x55')) - self.assertEquals('255.255.255.255', g('\xff\xff\xff\xff')) + self.assertEqual('1.0.1.0', g('\x01\x00\x01\x00')) + self.assertEqual('170.85.170.85', g('\xaa\x55\xaa\x55')) + self.assertEqual('255.255.255.255', g('\xff\xff\xff\xff')) def testStringToIPv6(self): if not hasattr(socket, 'inet_ntop'): @@ -490,9 +490,9 @@ class GeneralModuleTests(unittest.TestCase): return f = lambda a: inet_ntop(AF_INET6, a) - self.assertEquals('::', f('\x00' * 16)) - self.assertEquals('::1', f('\x00' * 15 + '\x01')) - self.assertEquals( + self.assertEqual('::', f('\x00' * 16)) + self.assertEqual('::1', f('\x00' * 15 + '\x01')) + self.assertEqual( 'aef:b01:506:1001:ffff:9997:55:170', f('\x0a\xef\x0b\x01\x05\x06\x10\x01\xff\xff\x99\x97\x00\x55\x01\x70') ) @@ -1016,8 +1016,8 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : "", ]) fo = socket._fileobject(mock_sock, **kwargs) - self.assertEquals(fo.readline(size), "This is the first line\n") - self.assertEquals(fo.readline(size), "And the second line is here\n") + self.assertEqual(fo.readline(size), "This is the first line\n") + self.assertEqual(fo.readline(size), "And the second line is here\n") def _test_read(self, size=-1, **kwargs): mock_sock = self.MockSocket(recv_funcs=[ @@ -1027,7 +1027,7 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : "", ]) fo = socket._fileobject(mock_sock, **kwargs) - self.assertEquals(fo.read(size), "This is the first line\n" + self.assertEqual(fo.read(size), "This is the first line\n" "And the second line is here\n") def test_default(self): @@ -1052,8 +1052,8 @@ class FileObjectInterruptedTestCase(unittest.TestCase): lambda : "", ]) fo = socket._fileobject(mock_sock, bufsize=0) - self.assertEquals(fo.readline(size), "aa\n") - self.assertEquals(fo.readline(size), "BBbb") + self.assertEqual(fo.readline(size), "aa\n") + self.assertEqual(fo.readline(size), "BBbb") def test_no_buffer(self): self._test_readline_no_buffer() @@ -1192,7 +1192,7 @@ class NetworkConnectionAttributesTest(SocketTCPTest, ThreadableTest): self.addCleanup(self.cli.close) finally: socket.setdefaulttimeout(None) - self.assertEquals(self.cli.gettimeout(), 42) + self.assertEqual(self.cli.gettimeout(), 42) testTimeoutNone = _justAccept def _testTimeoutNone(self): diff --git a/Lib/test/test_socketserver.py b/Lib/test/test_socketserver.py index d4c4f63..4825a4a 100644 --- a/Lib/test/test_socketserver.py +++ b/Lib/test/test_socketserver.py @@ -57,8 +57,8 @@ def simple_subprocess(testcase): os._exit(72) yield None pid2, status = os.waitpid(pid, 0) - testcase.assertEquals(pid2, pid) - testcase.assertEquals(72 << 8, status) + testcase.assertEqual(pid2, pid) + testcase.assertEqual(72 << 8, status) @unittest.skipUnless(threading, 'Threading required for this test.') @@ -120,7 +120,7 @@ class SocketServerTest(unittest.TestCase): if verbose: print "creating server" server = MyServer(addr, MyHandler) - self.assertEquals(server.server_address, server.socket.getsockname()) + self.assertEqual(server.server_address, server.socket.getsockname()) return server @unittest.skipUnless(threading, 'Threading required for this test.') @@ -161,7 +161,7 @@ class SocketServerTest(unittest.TestCase): while data and '\n' not in buf: data = receive(s, 100) buf += data - self.assertEquals(buf, TEST_STR) + self.assertEqual(buf, TEST_STR) s.close() def dgram_examine(self, proto, addr): @@ -171,7 +171,7 @@ class SocketServerTest(unittest.TestCase): while data and '\n' not in buf: data = receive(s, 100) buf += data - self.assertEquals(buf, TEST_STR) + self.assertEqual(buf, TEST_STR) s.close() def test_TCPServer(self): diff --git a/Lib/test/test_strop.py b/Lib/test/test_strop.py index 0172957..8ce29ef 100644 --- a/Lib/test/test_strop.py +++ b/Lib/test/test_strop.py @@ -123,7 +123,7 @@ class StropFunctionTestCase(unittest.TestCase): except OverflowError: pass else: - self.assertEquals(len(r), len(a) * 3) + self.assertEqual(len(r), len(a) * 3) @test_support.precisionbigmemtest(size=test_support._2G - 1, memuse=1) def test_stropjoin_huge_tup(self, size): @@ -133,7 +133,7 @@ class StropFunctionTestCase(unittest.TestCase): except OverflowError: pass # acceptable on 32-bit else: - self.assertEquals(len(r), len(a) * 3) + self.assertEqual(len(r), len(a) * 3) transtable = '\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037 !"#$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`xyzdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377' diff --git a/Lib/test/test_structmembers.py b/Lib/test/test_structmembers.py index ff1711c..0cc58c3 100644 --- a/Lib/test/test_structmembers.py +++ b/Lib/test/test_structmembers.py @@ -15,61 +15,61 @@ class ReadWriteTests(unittest.TestCase): def test_bool(self): ts.T_BOOL = True - self.assertEquals(ts.T_BOOL, True) + self.assertEqual(ts.T_BOOL, True) ts.T_BOOL = False - self.assertEquals(ts.T_BOOL, False) + self.assertEqual(ts.T_BOOL, False) self.assertRaises(TypeError, setattr, ts, 'T_BOOL', 1) def test_byte(self): ts.T_BYTE = CHAR_MAX - self.assertEquals(ts.T_BYTE, CHAR_MAX) + self.assertEqual(ts.T_BYTE, CHAR_MAX) ts.T_BYTE = CHAR_MIN - self.assertEquals(ts.T_BYTE, CHAR_MIN) + self.assertEqual(ts.T_BYTE, CHAR_MIN) ts.T_UBYTE = UCHAR_MAX - self.assertEquals(ts.T_UBYTE, UCHAR_MAX) + self.assertEqual(ts.T_UBYTE, UCHAR_MAX) def test_short(self): ts.T_SHORT = SHRT_MAX - self.assertEquals(ts.T_SHORT, SHRT_MAX) + self.assertEqual(ts.T_SHORT, SHRT_MAX) ts.T_SHORT = SHRT_MIN - self.assertEquals(ts.T_SHORT, SHRT_MIN) + self.assertEqual(ts.T_SHORT, SHRT_MIN) ts.T_USHORT = USHRT_MAX - self.assertEquals(ts.T_USHORT, USHRT_MAX) + self.assertEqual(ts.T_USHORT, USHRT_MAX) def test_int(self): ts.T_INT = INT_MAX - self.assertEquals(ts.T_INT, INT_MAX) + self.assertEqual(ts.T_INT, INT_MAX) ts.T_INT = INT_MIN - self.assertEquals(ts.T_INT, INT_MIN) + self.assertEqual(ts.T_INT, INT_MIN) ts.T_UINT = UINT_MAX - self.assertEquals(ts.T_UINT, UINT_MAX) + self.assertEqual(ts.T_UINT, UINT_MAX) def test_long(self): ts.T_LONG = LONG_MAX - self.assertEquals(ts.T_LONG, LONG_MAX) + self.assertEqual(ts.T_LONG, LONG_MAX) ts.T_LONG = LONG_MIN - self.assertEquals(ts.T_LONG, LONG_MIN) + self.assertEqual(ts.T_LONG, LONG_MIN) ts.T_ULONG = ULONG_MAX - self.assertEquals(ts.T_ULONG, ULONG_MAX) + self.assertEqual(ts.T_ULONG, ULONG_MAX) @unittest.skipUnless(hasattr(ts, "T_LONGLONG"), "long long not present") def test_longlong(self): ts.T_LONGLONG = LLONG_MAX - self.assertEquals(ts.T_LONGLONG, LLONG_MAX) + self.assertEqual(ts.T_LONGLONG, LLONG_MAX) ts.T_LONGLONG = LLONG_MIN - self.assertEquals(ts.T_LONGLONG, LLONG_MIN) + self.assertEqual(ts.T_LONGLONG, LLONG_MIN) ts.T_ULONGLONG = ULLONG_MAX - self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX) + self.assertEqual(ts.T_ULONGLONG, ULLONG_MAX) ## make sure these will accept a plain int as well as a long ts.T_LONGLONG = 3 - self.assertEquals(ts.T_LONGLONG, 3) + self.assertEqual(ts.T_LONGLONG, 3) ts.T_ULONGLONG = 4 - self.assertEquals(ts.T_ULONGLONG, 4) + self.assertEqual(ts.T_ULONGLONG, 4) def test_inplace_string(self): - self.assertEquals(ts.T_STRING_INPLACE, "hi") + self.assertEqual(ts.T_STRING_INPLACE, "hi") self.assertRaises(TypeError, setattr, ts, "T_STRING_INPLACE", "s") self.assertRaises(TypeError, delattr, ts, "T_STRING_INPLACE") diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py index 53cdcb2..49f5388 100644 --- a/Lib/test/test_sys.py +++ b/Lib/test/test_sys.py @@ -120,7 +120,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(0) except SystemExit, exc: - self.assertEquals(exc.code, 0) + self.assertEqual(exc.code, 0) except: self.fail("wrong exception") else: @@ -131,7 +131,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit(42) except SystemExit, exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -141,7 +141,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((42,)) except SystemExit, exc: - self.assertEquals(exc.code, 42) + self.assertEqual(exc.code, 42) except: self.fail("wrong exception") else: @@ -151,7 +151,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit("exit") except SystemExit, exc: - self.assertEquals(exc.code, "exit") + self.assertEqual(exc.code, "exit") except: self.fail("wrong exception") else: @@ -161,7 +161,7 @@ class SysModuleTest(unittest.TestCase): try: sys.exit((17, 23)) except SystemExit, exc: - self.assertEquals(exc.code, (17, 23)) + self.assertEqual(exc.code, (17, 23)) except: self.fail("wrong exception") else: @@ -213,7 +213,7 @@ class SysModuleTest(unittest.TestCase): orig = sys.getcheckinterval() for n in 0, 100, 120, orig: # orig last to restore starting state sys.setcheckinterval(n) - self.assertEquals(sys.getcheckinterval(), n) + self.assertEqual(sys.getcheckinterval(), n) def test_recursionlimit(self): self.assertRaises(TypeError, sys.getrecursionlimit, 42) diff --git a/Lib/test/test_sysconfig.py b/Lib/test/test_sysconfig.py index 88722de..142eb2f 100644 --- a/Lib/test/test_sysconfig.py +++ b/Lib/test/test_sysconfig.py @@ -87,7 +87,7 @@ class TestSysConfig(unittest.TestCase): shutil.rmtree(path) def test_get_path_names(self): - self.assertEquals(get_path_names(), sysconfig._SCHEME_KEYS) + self.assertEqual(get_path_names(), sysconfig._SCHEME_KEYS) def test_get_paths(self): scheme = get_paths() @@ -97,7 +97,7 @@ class TestSysConfig(unittest.TestCase): wanted.sort() scheme = scheme.items() scheme.sort() - self.assertEquals(scheme, wanted) + self.assertEqual(scheme, wanted) def test_get_path(self): # xxx make real tests here @@ -116,21 +116,21 @@ class TestSysConfig(unittest.TestCase): sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Intel)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win32') + self.assertEqual(get_platform(), 'win32') # windows XP, amd64 os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Amd64)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-amd64') + self.assertEqual(get_platform(), 'win-amd64') # windows XP, itanium os.name = 'nt' sys.version = ('2.4.4 (#71, Oct 18 2006, 08:34:43) ' '[MSC v.1310 32 bit (Itanium)]') sys.platform = 'win32' - self.assertEquals(get_platform(), 'win-ia64') + self.assertEqual(get_platform(), 'win-ia64') # macbook os.name = 'posix' @@ -149,9 +149,9 @@ class TestSysConfig(unittest.TestCase): maxint = sys.maxint try: sys.maxint = 2147483647 - self.assertEquals(get_platform(), 'macosx-10.3-ppc') + self.assertEqual(get_platform(), 'macosx-10.3-ppc') sys.maxint = 9223372036854775807 - self.assertEquals(get_platform(), 'macosx-10.3-ppc64') + self.assertEqual(get_platform(), 'macosx-10.3-ppc64') finally: sys.maxint = maxint @@ -169,9 +169,9 @@ class TestSysConfig(unittest.TestCase): maxint = sys.maxint try: sys.maxint = 2147483647 - self.assertEquals(get_platform(), 'macosx-10.3-i386') + self.assertEqual(get_platform(), 'macosx-10.3-i386') sys.maxint = 9223372036854775807 - self.assertEquals(get_platform(), 'macosx-10.3-x86_64') + self.assertEqual(get_platform(), 'macosx-10.3-x86_64') finally: sys.maxint = maxint @@ -182,33 +182,33 @@ class TestSysConfig(unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat') + self.assertEqual(get_platform(), 'macosx-10.4-fat') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-intel') + self.assertEqual(get_platform(), 'macosx-10.4-intel') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat3') + self.assertEqual(get_platform(), 'macosx-10.4-fat3') get_config_vars()['CFLAGS'] = ('-arch ppc64 -arch x86_64 -arch ppc -arch i386 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-universal') + self.assertEqual(get_platform(), 'macosx-10.4-universal') get_config_vars()['CFLAGS'] = ('-arch x86_64 -arch ppc64 -isysroot ' '/Developer/SDKs/MacOSX10.4u.sdk ' '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3') - self.assertEquals(get_platform(), 'macosx-10.4-fat64') + self.assertEqual(get_platform(), 'macosx-10.4-fat64') for arch in ('ppc', 'i386', 'x86_64', 'ppc64'): get_config_vars()['CFLAGS'] = ('-arch %s -isysroot ' @@ -216,7 +216,7 @@ class TestSysConfig(unittest.TestCase): '-fno-strict-aliasing -fno-common ' '-dynamic -DNDEBUG -g -O3'%(arch,)) - self.assertEquals(get_platform(), 'macosx-10.4-%s'%(arch,)) + self.assertEqual(get_platform(), 'macosx-10.4-%s'%(arch,)) # linux debian sarge os.name = 'posix' @@ -226,7 +226,7 @@ class TestSysConfig(unittest.TestCase): self._set_uname(('Linux', 'aglae', '2.6.21.1dedibox-r7', '#1 Mon Apr 30 17:25:38 CEST 2007', 'i686')) - self.assertEquals(get_platform(), 'linux-i686') + self.assertEqual(get_platform(), 'linux-i686') # XXX more platforms to tests here @@ -237,7 +237,7 @@ class TestSysConfig(unittest.TestCase): def test_get_scheme_names(self): wanted = ('nt', 'nt_user', 'os2', 'os2_home', 'osx_framework_user', 'posix_home', 'posix_prefix', 'posix_user') - self.assertEquals(get_scheme_names(), wanted) + self.assertEqual(get_scheme_names(), wanted) def test_symlink(self): # Issue 7880 @@ -263,7 +263,7 @@ class TestSysConfig(unittest.TestCase): for name in ('stdlib', 'platstdlib', 'purelib', 'platlib'): global_path = get_path(name, 'posix_prefix') user_path = get_path(name, 'posix_user') - self.assertEquals(user_path, global_path.replace(base, user)) + self.assertEqual(user_path, global_path.replace(base, user)) def test_main(): run_unittest(TestSysConfig) diff --git a/Lib/test/test_tcl.py b/Lib/test/test_tcl.py index 1b3c1cc..e8ba58f 100644 --- a/Lib/test/test_tcl.py +++ b/Lib/test/test_tcl.py @@ -147,7 +147,7 @@ class TclTest(unittest.TestCase): env.unset("TCL_LIBRARY") f = os.popen('%s -c "import Tkinter; print Tkinter"' % (unc_name,)) - self.assert_('Tkinter.py' in f.read()) + self.assertTrue('Tkinter.py' in f.read()) # exit code must be zero self.assertEqual(f.close(), None) diff --git a/Lib/test/test_textwrap.py b/Lib/test/test_textwrap.py index c7da26b..63a54d9 100644 --- a/Lib/test/test_textwrap.py +++ b/Lib/test/test_textwrap.py @@ -29,7 +29,7 @@ class BaseTestCase(unittest.TestCase): def check(self, result, expect): - self.assertEquals(result, expect, + self.assertEqual(result, expect, 'expected:\n%s\nbut got:\n%s' % ( self.show(expect), self.show(result))) @@ -39,9 +39,9 @@ class BaseTestCase(unittest.TestCase): def check_split(self, text, expect): result = self.wrapper._split(text) - self.assertEquals(result, expect, - "\nexpected %r\n" - "but got %r" % (expect, result)) + self.assertEqual(result, expect, + "\nexpected %r\n" + "but got %r" % (expect, result)) class WrapTestCase(BaseTestCase): @@ -504,7 +504,7 @@ class DedentTestCase(unittest.TestCase): def assertUnchanged(self, text): """assert that dedent() has no effect on 'text'""" - self.assertEquals(text, dedent(text)) + self.assertEqual(text, dedent(text)) def test_dedent_nomargin(self): # No lines indented. @@ -527,17 +527,17 @@ class DedentTestCase(unittest.TestCase): # All lines indented by two spaces. text = " Hello there.\n How are ya?\n Oh good." expect = "Hello there.\nHow are ya?\nOh good." - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Same, with blank lines. text = " Hello there.\n\n How are ya?\n Oh good.\n" expect = "Hello there.\n\nHow are ya?\nOh good.\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Now indent one of the blank lines. text = " Hello there.\n \n How are ya?\n Oh good.\n" expect = "Hello there.\n\nHow are ya?\nOh good.\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) def test_dedent_uneven(self): # Lines indented unevenly. @@ -551,27 +551,27 @@ def foo(): while 1: return foo ''' - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Uneven indentation with a blank line. text = " Foo\n Bar\n\n Baz\n" expect = "Foo\n Bar\n\n Baz\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # Uneven indentation with a whitespace-only line. text = " Foo\n Bar\n \n Baz\n" expect = "Foo\n Bar\n\n Baz\n" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # dedent() should not mangle internal tabs def test_dedent_preserve_internal_tabs(self): text = " hello\tthere\n how are\tyou?" expect = "hello\tthere\nhow are\tyou?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) # make sure that it preserves tabs when it's not making any # changes at all - self.assertEquals(expect, dedent(expect)) + self.assertEqual(expect, dedent(expect)) # dedent() should not mangle tabs in the margin (i.e. # tabs and spaces both count as margin, but are *not* @@ -587,17 +587,17 @@ def foo(): # dedent() only removes whitespace that can be uniformly removed! text = "\thello there\n\thow are you?" expect = "hello there\nhow are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) text = " \thello there\n \thow are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) text = " \t hello there\n \t how are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) text = " \thello there\n \t how are you?" expect = "hello there\n how are you?" - self.assertEquals(expect, dedent(text)) + self.assertEqual(expect, dedent(text)) def test_main(): diff --git a/Lib/test/test_threadedtempfile.py b/Lib/test/test_threadedtempfile.py index 4aeb711..81d9687 100644 --- a/Lib/test/test_threadedtempfile.py +++ b/Lib/test/test_threadedtempfile.py @@ -68,8 +68,8 @@ class ThreadedTempFileTest(unittest.TestCase): msg = "Errors: errors %d ok %d\n%s" % (len(errors), ok, '\n'.join(errors)) - self.assertEquals(errors, [], msg) - self.assertEquals(ok, NUM_THREADS * FILES_PER_THREAD) + self.assertEqual(errors, [], msg) + self.assertEqual(ok, NUM_THREADS * FILES_PER_THREAD) def test_main(): run_unittest(ThreadedTempFileTest) diff --git a/Lib/test/test_threading.py b/Lib/test/test_threading.py index a06415d..0ca19b2 100644 --- a/Lib/test/test_threading.py +++ b/Lib/test/test_threading.py @@ -403,17 +403,17 @@ class ThreadTests(BaseTestCase): weak_cyclic_object = weakref.ref(cyclic_object) cyclic_object.thread.join() del cyclic_object - self.assertEquals(None, weak_cyclic_object(), - msg=('%d references still around' % - sys.getrefcount(weak_cyclic_object()))) + self.assertEqual(None, weak_cyclic_object(), + msg=('%d references still around' % + sys.getrefcount(weak_cyclic_object()))) raising_cyclic_object = RunSelfFunction(should_raise=True) weak_raising_cyclic_object = weakref.ref(raising_cyclic_object) raising_cyclic_object.thread.join() del raising_cyclic_object - self.assertEquals(None, weak_raising_cyclic_object(), - msg=('%d references still around' % - sys.getrefcount(weak_raising_cyclic_object()))) + self.assertEqual(None, weak_raising_cyclic_object(), + msg=('%d references still around' % + sys.getrefcount(weak_raising_cyclic_object()))) class ThreadJoinOnShutdown(BaseTestCase): diff --git a/Lib/test/test_time.py b/Lib/test/test_time.py index 6683de6..a1029fd 100644 --- a/Lib/test/test_time.py +++ b/Lib/test/test_time.py @@ -94,7 +94,7 @@ class TimeTestCase(unittest.TestCase): # based on its value. expected = "2000 01 01 00 00 00 1 001" result = time.strftime("%Y %m %d %H %M %S %w %j", (0,)*9) - self.assertEquals(expected, result) + self.assertEqual(expected, result) def test_strptime(self): # Should be able to go round-trip from strftime to strptime without diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py index 3b6c614..7a982f1 100644 --- a/Lib/test/test_trace.py +++ b/Lib/test/test_trace.py @@ -309,7 +309,7 @@ class TestCoverage(unittest.TestCase): self._coverage(tracer) if os.path.exists(TESTFN): files = os.listdir(TESTFN) - self.assertEquals(files, []) + self.assertEqual(files, []) def test_issue9936(self): tracer = trace.Trace(trace=0, count=1) diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py index 811feac..8076be8 100644 --- a/Lib/test/test_traceback.py +++ b/Lib/test/test_traceback.py @@ -185,11 +185,11 @@ class TracebackFormatTests(unittest.TestCase): raise Error("unable to create test traceback string") # Make sure that Python and the traceback module format the same thing - self.assertEquals(traceback_fmt, python_fmt) + self.assertEqual(traceback_fmt, python_fmt) # Make sure that the traceback is properly indented. tb_lines = python_fmt.splitlines() - self.assertEquals(len(tb_lines), 3) + self.assertEqual(len(tb_lines), 3) banner, location, source_line = tb_lines self.assertTrue(banner.startswith('Traceback')) self.assertTrue(location.startswith(' File')) diff --git a/Lib/test/test_unicodedata.py b/Lib/test/test_unicodedata.py index 4904f70..e8d5d8f 100644 --- a/Lib/test/test_unicodedata.py +++ b/Lib/test/test_unicodedata.py @@ -252,7 +252,7 @@ class UnicodeMiscTest(UnicodeDatabaseTest): self.assertTrue(count >= 10) # should have tested at least the ASCII digits def test_bug_1704793(self): - self.assertEquals(self.db.lookup("GOTHIC LETTER FAIHU"), u'\U00010346') + self.assertEqual(self.db.lookup("GOTHIC LETTER FAIHU"), u'\U00010346') def test_ucd_510(self): import unicodedata diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py index 7119f55..c6e24d6 100644 --- a/Lib/test/test_urllib.py +++ b/Lib/test/test_urllib.py @@ -112,7 +112,7 @@ class ProxyTests(unittest.TestCase): self.env.set('NO_PROXY', 'localhost') proxies = urllib.getproxies_environment() # getproxies_environment use lowered case truncated (no '_proxy') keys - self.assertEquals('localhost', proxies['no']) + self.assertEqual('localhost', proxies['no']) class urlopen_HttpTests(unittest.TestCase): diff --git a/Lib/test/test_urllib2.py b/Lib/test/test_urllib2.py index 983ffa8..46db6b4 100644 --- a/Lib/test/test_urllib2.py +++ b/Lib/test/test_urllib2.py @@ -45,7 +45,7 @@ class TrivialTests(unittest.TestCase): ('a, b, "c", "d", "e,f", g, h', ['a', 'b', '"c"', '"d"', '"e,f"', 'g', 'h']), ('a="b\\"c", d="e\\,f", g="h\\\\i"', ['a="b"c"', 'd="e,f"', 'g="h\\i"'])] for string, list in tests: - self.assertEquals(urllib2.parse_http_list(string), list) + self.assertEqual(urllib2.parse_http_list(string), list) def test_request_headers_dict(): @@ -872,7 +872,7 @@ class HandlerTests(unittest.TestCase): r = MockResponse(200, "OK", {}, "") newreq = h.http_request(req) self.assertTrue(cj.ach_req is req is newreq) - self.assertEquals(req.get_origin_req_host(), "example.com") + self.assertEqual(req.get_origin_req_host(), "example.com") self.assertTrue(not req.is_unverifiable()) newr = h.http_response(req, r) self.assertTrue(cj.ec_req is req) diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py index 5d8a484..0fda770 100644 --- a/Lib/test/test_urllib2_localnet.py +++ b/Lib/test/test_urllib2_localnet.py @@ -371,8 +371,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/', '/somewhere_else']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/', '/somewhere_else']) finally: self.server.stop() @@ -392,8 +392,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/weeble']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/weeble']) finally: self.server.stop() @@ -407,8 +407,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/bizarre']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/bizarre']) finally: self.server.stop() @@ -421,8 +421,8 @@ class TestUrlopen(BaseTestCase): data = f.read() f.close() - self.assertEquals(data, expected_response) - self.assertEquals(handler.requests, ['/bizarre', 'get=with_feeling']) + self.assertEqual(data, expected_response) + self.assertEqual(handler.requests, ['/bizarre', 'get=with_feeling']) finally: self.server.stop() diff --git a/Lib/test/test_userstring.py b/Lib/test/test_userstring.py index 7e5df78..2625985 100755 --- a/Lib/test/test_userstring.py +++ b/Lib/test/test_userstring.py @@ -104,11 +104,11 @@ class MutableStringTest(UserStringTest): data.reverse() L[start:stop:step] = data s[start:stop:step] = "".join(data) - self.assertEquals(s, "".join(L)) + self.assertEqual(s, "".join(L)) del L[start:stop:step] del s[start:stop:step] - self.assertEquals(s, "".join(L)) + self.assertEqual(s, "".join(L)) def test_immutable(self): s = self.type2test("foobar") diff --git a/Lib/test/test_warnings.py b/Lib/test/test_warnings.py index bc8d0b8..1c2c0c2 100644 --- a/Lib/test/test_warnings.py +++ b/Lib/test/test_warnings.py @@ -80,7 +80,7 @@ class FilterTests(object): self.module.resetwarnings() self.module.filterwarnings("ignore", category=UserWarning) self.module.warn("FilterTests.test_ignore", UserWarning) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_always(self): with original_warnings.catch_warnings(record=True, @@ -102,10 +102,10 @@ class FilterTests(object): for x in xrange(2): self.module.warn(message, UserWarning) if x == 0: - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] elif x == 1: - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) else: raise ValueError("loop variant unhandled") @@ -116,10 +116,10 @@ class FilterTests(object): self.module.filterwarnings("module", category=UserWarning) message = UserWarning("FilterTests.test_module") self.module.warn(message, UserWarning) - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] self.module.warn(message, UserWarning) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_once(self): with original_warnings.catch_warnings(record=True, @@ -129,14 +129,14 @@ class FilterTests(object): message = UserWarning("FilterTests.test_once") self.module.warn_explicit(message, UserWarning, "test_warnings.py", 42) - self.assertEquals(w[-1].message, message) + self.assertEqual(w[-1].message, message) del w[:] self.module.warn_explicit(message, UserWarning, "test_warnings.py", 13) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) self.module.warn_explicit(message, UserWarning, "test_warnings2.py", 42) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_inheritance(self): with original_warnings.catch_warnings(module=self.module) as w: @@ -157,7 +157,7 @@ class FilterTests(object): self.module.warn("FilterTests.test_ordering", UserWarning) except UserWarning: self.fail("order handling for actions failed") - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) def test_filterwarnings(self): # Test filterwarnings(). @@ -436,7 +436,7 @@ class _WarningsTests(BaseTest): self.assertEqual(w[-1].message, message) del w[:] self.module.warn_explicit(message, UserWarning, "file", 42) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) # Test the resetting of onceregistry. self.module.onceregistry = {} __warningregistry__ = {} @@ -447,7 +447,7 @@ class _WarningsTests(BaseTest): del self.module.onceregistry __warningregistry__ = {} self.module.warn_explicit(message, UserWarning, "file", 42) - self.assertEquals(len(w), 0) + self.assertEqual(len(w), 0) finally: self.module.onceregistry = original_registry diff --git a/Lib/test/test_winreg.py b/Lib/test/test_winreg.py index ad4cf42..12ab3ba 100644 --- a/Lib/test/test_winreg.py +++ b/Lib/test/test_winreg.py @@ -88,11 +88,11 @@ class BaseWinregTests(unittest.TestCase): # Check we wrote as many items as we thought. nkeys, nvalues, since_mod = QueryInfoKey(key) - self.assertEquals(nkeys, 1, "Not the correct number of sub keys") - self.assertEquals(nvalues, 1, "Not the correct number of values") + self.assertEqual(nkeys, 1, "Not the correct number of sub keys") + self.assertEqual(nvalues, 1, "Not the correct number of values") nkeys, nvalues, since_mod = QueryInfoKey(sub_key) - self.assertEquals(nkeys, 0, "Not the correct number of sub keys") - self.assertEquals(nvalues, len(test_data), + self.assertEqual(nkeys, 0, "Not the correct number of sub keys") + self.assertEqual(nvalues, len(test_data), "Not the correct number of values") # Close this key this way... # (but before we do, copy the key as an integer - this allows @@ -118,8 +118,8 @@ class BaseWinregTests(unittest.TestCase): def _read_test_data(self, root_key, OpenKey=OpenKey): # Check we can get default value for this key. val = QueryValue(root_key, test_key_name) - self.assertEquals(val, "Default value", - "Registry didn't give back the correct value") + self.assertEqual(val, "Default value", + "Registry didn't give back the correct value") key = OpenKey(root_key, test_key_name) # Read the sub-keys @@ -134,19 +134,19 @@ class BaseWinregTests(unittest.TestCase): self.assertIn(data, test_data, "Didn't read back the correct test data") index = index + 1 - self.assertEquals(index, len(test_data), - "Didn't read the correct number of items") + self.assertEqual(index, len(test_data), + "Didn't read the correct number of items") # Check I can directly access each item for value_name, value_data, value_type in test_data: read_val, read_typ = QueryValueEx(sub_key, value_name) - self.assertEquals(read_val, value_data, - "Could not directly read the value") - self.assertEquals(read_typ, value_type, - "Could not directly read the value") + self.assertEqual(read_val, value_data, + "Could not directly read the value") + self.assertEqual(read_typ, value_type, + "Could not directly read the value") sub_key.Close() # Enumerate our main key. read_val = EnumKey(key, 0) - self.assertEquals(read_val, "sub_key", "Read subkey value wrong") + self.assertEqual(read_val, "sub_key", "Read subkey value wrong") try: EnumKey(key, 1) self.fail("Was able to get a second key when I only have one!") @@ -165,8 +165,8 @@ class BaseWinregTests(unittest.TestCase): DeleteValue(sub_key, value_name) nkeys, nvalues, since_mod = QueryInfoKey(sub_key) - self.assertEquals(nkeys, 0, "subkey not empty before delete") - self.assertEquals(nvalues, 0, "subkey not empty before delete") + self.assertEqual(nkeys, 0, "subkey not empty before delete") + self.assertEqual(nvalues, 0, "subkey not empty before delete") sub_key.Close() DeleteKey(key, "sub_key") @@ -326,8 +326,8 @@ class Win64WinregTests(BaseWinregTests): with OpenKey(HKEY_LOCAL_MACHINE, "Software") as key: # HKLM\Software is redirected but not reflected in all OSes self.assertTrue(QueryReflectionKey(key)) - self.assertEquals(None, EnableReflectionKey(key)) - self.assertEquals(None, DisableReflectionKey(key)) + self.assertEqual(None, EnableReflectionKey(key)) + self.assertEqual(None, DisableReflectionKey(key)) self.assertTrue(QueryReflectionKey(key)) @unittest.skipUnless(HAS_REFLECTION, "OS doesn't support reflection") diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py index a1ec80b..49645183 100644 --- a/Lib/test/test_with.py +++ b/Lib/test/test_with.py @@ -732,10 +732,10 @@ class NestedWith(unittest.TestCase): def testEnterReturnsTuple(self): with self.Dummy(value=(1,2)) as (a1, a2), \ self.Dummy(value=(10, 20)) as (b1, b2): - self.assertEquals(1, a1) - self.assertEquals(2, a2) - self.assertEquals(10, b1) - self.assertEquals(20, b2) + self.assertEqual(1, a1) + self.assertEqual(2, a2) + self.assertEqual(10, b1) + self.assertEqual(20, b2) def test_main(): run_unittest(FailureTestCase, NonexceptionalTestCase, diff --git a/Lib/test/test_xmllib.py b/Lib/test/test_xmllib.py index 68b883a..966978a 100644 --- a/Lib/test/test_xmllib.py +++ b/Lib/test/test_xmllib.py @@ -36,9 +36,9 @@ class XMLParserTestCase(unittest.TestCase): h.feed(nsdoc) h.close() # The default namespace applies to elements... - self.assertEquals(h.name, "URI foo") + self.assertEqual(h.name, "URI foo") # but not to attributes - self.assertEquals(h.attr, {'attr':'val'}) + self.assertEqual(h.attr, {'attr':'val'}) def test_main(): diff --git a/Lib/test/test_xmlrpc.py b/Lib/test/test_xmlrpc.py index 2a3b2d9..6310c97 100644 --- a/Lib/test/test_xmlrpc.py +++ b/Lib/test/test_xmlrpc.py @@ -44,8 +44,8 @@ alist = [{'astring': 'foo@bar.baz.spam', class XMLRPCTestCase(unittest.TestCase): def test_dump_load(self): - self.assertEquals(alist, - xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0]) + self.assertEqual(alist, + xmlrpclib.loads(xmlrpclib.dumps((alist,)))[0][0]) def test_dump_bare_datetime(self): # This checks that an unwrapped datetime.date object can be handled @@ -55,22 +55,22 @@ class XMLRPCTestCase(unittest.TestCase): dt = datetime.datetime(2005, 02, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEquals(newdt, dt) - self.assertEquals(m, None) + self.assertEqual(newdt, dt) + self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEquals(newdt, xmlrpclib.DateTime('20050210T11:41:23')) + self.assertEqual(newdt, xmlrpclib.DateTime('20050210T11:41:23')) def test_datetime_before_1900(self): # same as before but with a date before 1900 dt = datetime.datetime(1, 02, 10, 11, 41, 23) s = xmlrpclib.dumps((dt,)) (newdt,), m = xmlrpclib.loads(s, use_datetime=1) - self.assertEquals(newdt, dt) - self.assertEquals(m, None) + self.assertEqual(newdt, dt) + self.assertEqual(m, None) (newdt,), m = xmlrpclib.loads(s, use_datetime=0) - self.assertEquals(newdt, xmlrpclib.DateTime('00010210T11:41:23')) + self.assertEqual(newdt, xmlrpclib.DateTime('00010210T11:41:23')) def test_cmp_datetime_DateTime(self): now = datetime.datetime.now() @@ -98,7 +98,7 @@ class XMLRPCTestCase(unittest.TestCase): t.x = 100 t.y = "Hello" ((t2,), dummy) = xmlrpclib.loads(xmlrpclib.dumps((t,))) - self.assertEquals(t2, t.__dict__) + self.assertEqual(t2, t.__dict__) def test_dump_big_long(self): self.assertRaises(OverflowError, xmlrpclib.dumps, (2L**99,)) @@ -141,8 +141,8 @@ class XMLRPCTestCase(unittest.TestCase): value = alist + [None] arg1 = (alist + [None],) strg = xmlrpclib.dumps(arg1, allow_none=True) - self.assertEquals(value, - xmlrpclib.loads(strg)[0][0]) + self.assertEqual(value, + xmlrpclib.loads(strg)[0][0]) self.assertRaises(TypeError, xmlrpclib.dumps, (arg1,)) def test_default_encoding_issues(self): @@ -178,14 +178,14 @@ class XMLRPCTestCase(unittest.TestCase): items = d.items() if have_unicode: - self.assertEquals(s, u"abc \x95") + self.assertEqual(s, u"abc \x95") self.assertIsInstance(s, unicode) - self.assertEquals(items, [(u"def \x96", u"ghi \x97")]) + self.assertEqual(items, [(u"def \x96", u"ghi \x97")]) self.assertIsInstance(items[0][0], unicode) self.assertIsInstance(items[0][1], unicode) else: - self.assertEquals(s, "abc \xc2\x95") - self.assertEquals(items, [("def \xc2\x96", "ghi \xc2\x97")]) + self.assertEqual(s, "abc \xc2\x95") + self.assertEqual(items, [("def \xc2\x96", "ghi \xc2\x97")]) class HelperTestCase(unittest.TestCase): @@ -204,8 +204,8 @@ class FaultTestCase(unittest.TestCase): f = xmlrpclib.Fault(42, 'Test Fault') s = xmlrpclib.dumps((f,)) (newf,), m = xmlrpclib.loads(s) - self.assertEquals(newf, {'faultCode': 42, 'faultString': 'Test Fault'}) - self.assertEquals(m, None) + self.assertEqual(newf, {'faultCode': 42, 'faultString': 'Test Fault'}) + self.assertEqual(m, None) s = xmlrpclib.Marshaller().dumps(f) self.assertRaises(xmlrpclib.Fault, xmlrpclib.loads, s) @@ -903,7 +903,7 @@ class CGIHandlerTestCase(unittest.TestCase): content = handle[handle.find("