traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

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.
........
This commit is contained in:
Ezio Melotti 2010-11-21 13:34:58 +00:00
parent 40a92f5c65
commit 2623a37852
184 changed files with 2328 additions and 2326 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Lib/bsddb/test/test_associate.py
View File

@ -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')

12
Lib/bsddb/test/test_basics.py
View File

@ -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,))

2
Lib/bsddb/test/test_compat.py
View File

@ -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.

10
Lib/bsddb/test/test_cursor_pget_bug.py
View File

@ -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()

2
Lib/bsddb/test/test_dbshelve.py
View File

@ -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')
#----------------------------------------------------------------------

4
Lib/bsddb/test/test_dbtables.py
View File

@ -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):

12
Lib/bsddb/test/test_distributed_transactions.py
View File

@ -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

2
Lib/bsddb/test/test_early_close.py
View File

@ -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

4
Lib/bsddb/test/test_fileid.py
View File

@ -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()

2
Lib/bsddb/test/test_get_none.py
View File

@ -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()

2
Lib/bsddb/test/test_join.py
View File

@ -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

6
Lib/bsddb/test/test_misc.py
View File

@ -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

2
Lib/bsddb/test/test_recno.py
View File

@ -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))) :

48
Lib/bsddb/test/test_replication.py
View File

@ -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()<timeout)
self.assertEquals("123", v)
self.assertEqual("123", v)
txn=self.dbenvMaster.txn_begin()
self.dbMaster.delete("ABC", txn=txn)
@ -220,7 +220,7 @@ class DBReplicationManager(DBReplication) :
if v is None :
time.sleep(0.02)
self.assertTrue(time.time()<timeout)
self.assertEquals(None, v)
self.assertEqual(None, v)
class DBBaseReplication(DBReplication) :
def setUp(self) :
@ -253,8 +253,8 @@ class DBBaseReplication(DBReplication) :
self.dbenvClient.rep_set_transport(3,c2m)
self.dbenvClient.rep_set_priority(0)
self.assertEquals(self.dbenvMaster.rep_get_priority(),10)
self.assertEquals(self.dbenvClient.rep_get_priority(),0)
self.assertEqual(self.dbenvMaster.rep_get_priority(),10)
self.assertEqual(self.dbenvClient.rep_get_priority(),0)
#self.dbenvMaster.set_verbose(db.DB_VERB_REPLICATION, True)
#self.dbenvMaster.set_verbose(db.DB_VERB_FILEOPS_ALL, True)
@ -384,7 +384,7 @@ class DBBaseReplication(DBReplication) :
if v is None :
time.sleep(0.02)
self.assertTrue(time.time()<timeout)
self.assertEquals("123", v)
self.assertEqual("123", v)
txn=self.dbenvMaster.txn_begin()
self.dbMaster.delete("ABC", txn=txn)
@ -397,7 +397,7 @@ class DBBaseReplication(DBReplication) :
if v is None :
time.sleep(0.02)
self.assertTrue(time.time()<timeout)
self.assertEquals(None, v)
self.assertEqual(None, v)
if db.version() >= (4,7) :
def test02_test_request(self) :

60
Lib/bsddb/test/test_sequence.py
View File

@ -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)

36
Lib/ctypes/test/test_keeprefs.py
View File

@ -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):

18
Lib/distutils/tests/test_archive_util.py
View File

@ -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']

4
Lib/distutils/tests/test_bdist.py
View File

@ -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)

8
Lib/distutils/tests/test_bdist_dumb.py
View File

@ -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)

14
Lib/distutils/tests/test_build.py
View File

@ -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.<plat>
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)

10
Lib/distutils/tests/test_build_clib.py
View File

@ -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)

86
Lib/distutils/tests/test_build_ext.py
View File

@ -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)

8
Lib/distutils/tests/test_ccompiler.py
View File

@ -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)

14
Lib/distutils/tests/test_check.py
View File

@ -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):

10
Lib/distutils/tests/test_cmd.py
View File

@ -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

6
Lib/distutils/tests/test_config.py
View File

@ -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()

12
Lib/distutils/tests/test_config_cmd.py
View File

@ -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

4
Lib/distutils/tests/test_core.py
View File

@ -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)

4
Lib/distutils/tests/test_dep_util.py
View File

@ -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()

22
Lib/distutils/tests/test_dir_util.py
View File

@ -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)

42
Lib/distutils/tests/test_dist.py
View File

@ -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()

8
Lib/distutils/tests/test_file_util.py
View File

@ -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()

20
Lib/distutils/tests/test_filelist.py
View File

@ -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

8
Lib/distutils/tests/test_install_data.py
View File

@ -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)))

4
Lib/distutils/tests/test_install_headers.py
View File

@ -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)

8
Lib/distutils/tests/test_install_lib.py
View File

@ -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

4
Lib/distutils/tests/test_msvc9compiler.py
View File

@ -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():

12
Lib/distutils/tests/test_register.py
View File

@ -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)

40
Lib/distutils/tests/test_sdist.py
View File

@ -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):

2
Lib/distutils/tests/test_spawn.py
View File

@ -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'),

10
Lib/distutils/tests/test_sysconfig.py
View File

@ -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():

2
Lib/distutils/tests/test_text_file.py
View File

@ -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")

14
Lib/distutils/tests/test_upload.py
View File

@ -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)

20
Lib/distutils/tests/test_version.py
View File

@ -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)

60
Lib/email/test/test_email.py
View File

@ -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: <https://lists.sourceforge.net/lists/listinfo/spamassass
""")
# Test mangling of "From " lines in the body of a message
class TestFromMangling(unittest.TestCase):
def setUp(self):
@ -927,7 +927,7 @@ Blah blah blah
""")
# Test the basic MIMEAudio class
class TestMIMEAudio(unittest.TestCase):
def setUp(self):
@ -976,7 +976,7 @@ class TestMIMEAudio(unittest.TestCase):
header='foobar') is missing)
# Test the basic MIMEImage class
class TestMIMEImage(unittest.TestCase):
def setUp(self):
@ -1019,7 +1019,7 @@ class TestMIMEImage(unittest.TestCase):
header='foobar') is missing)
# Test the basic MIMEText class
class TestMIMEText(unittest.TestCase):
def setUp(self):
@ -1071,7 +1071,7 @@ class TestMIMEText(unittest.TestCase):
self.assertRaises(UnicodeEncodeError, MIMEText, teststr)
# Test complicated multipart/* messages
class TestMultipart(TestEmailBase):
def setUp(self):
@ -1447,10 +1447,10 @@ Content-Transfer-Encoding: base64
YXNkZg==
--===============0012394164==--""")
self.assertEquals(m.get_payload(0).get_payload(), 'YXNkZg==')
self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
# Test some badly formatted messages
class TestNonConformant(TestEmailBase):
def test_parse_missing_minor_type(self):
@ -1565,7 +1565,7 @@ counter to RFC 2822, there's no separating newline here
# Test RFC 2047 header encoding and decoding
class TestRFC2047(unittest.TestCase):
def test_rfc2047_multiline(self):
@ -1627,7 +1627,7 @@ class TestRFC2047(unittest.TestCase):
self.assertEqual(decode_header(s),
[(b'andr\xe9=zz', 'iso-8659-1')])
# Test the MIMEMessage class
class TestMIMEMessage(TestEmailBase):
def setUp(self):
@ -1940,7 +1940,7 @@ message 2
msg = MIMEMultipart()
self.assertTrue(msg.is_multipart())
# A general test of parser->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')

60
Lib/email/test/test_email_renamed.py
View File

@ -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: <https://lists.sourceforge.net/lists/listinfo/spamassass
""")
# Test mangling of "From " lines in the body of a message
class TestFromMangling(unittest.TestCase):
def setUp(self):
@ -886,7 +886,7 @@ Blah blah blah
""")
# Test the basic MIMEAudio class
class TestMIMEAudio(unittest.TestCase):
def setUp(self):
@ -935,7 +935,7 @@ class TestMIMEAudio(unittest.TestCase):
header='foobar') is missing)
# Test the basic MIMEImage class
class TestMIMEImage(unittest.TestCase):
def setUp(self):
@ -978,7 +978,7 @@ class TestMIMEImage(unittest.TestCase):
header='foobar') is missing)
# Test the basic MIMEApplication class
class TestMIMEApplication(unittest.TestCase):
def test_headers(self):
@ -995,7 +995,7 @@ class TestMIMEApplication(unittest.TestCase):
eq(msg.get_payload(decode=True), bytes)
# Test the basic MIMEText class
class TestMIMEText(unittest.TestCase):
def setUp(self):
@ -1022,7 +1022,7 @@ class TestMIMEText(unittest.TestCase):
eq(msg['content-type'], 'text/plain; charset="us-ascii"')
# Test complicated multipart/* messages
class TestMultipart(TestEmailBase):
def setUp(self):
@ -1398,10 +1398,10 @@ Content-Transfer-Encoding: base64
YXNkZg==
--===============0012394164==--""")
self.assertEquals(m.get_payload(0).get_payload(), 'YXNkZg==')
self.assertEqual(m.get_payload(0).get_payload(), 'YXNkZg==')
# Test some badly formatted messages
class TestNonConformant(TestEmailBase):
def test_parse_missing_minor_type(self):
@ -1515,7 +1515,7 @@ counter to RFC 2822, there's no separating newline here
eq(msg.defects[0].line, ' Line 1\n')
# Test RFC 2047 header encoding and decoding
class TestRFC2047(unittest.TestCase):
def test_rfc2047_multiline(self):
@ -1562,7 +1562,7 @@ class TestRFC2047(unittest.TestCase):
('sbord', None)])
# Test the MIMEMessage class
class TestMIMEMessage(TestEmailBase):
def setUp(self):
@ -1872,7 +1872,7 @@ message 2
eq(msg.get_payload(1), text2)
# A general test of parser->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')

6
Lib/json/tests/test_decode.py
View File

@ -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}'

2
Lib/json/tests/test_default.py
View File

@ -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)))

8
Lib/json/tests/test_dump.py
View File

@ -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}')

2
Lib/json/tests/test_encode_basestring_ascii.py
View File

@ -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))

14
Lib/json/tests/test_float.py
View File

@ -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)

6
Lib/json/tests/test_indent.py
View File

@ -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)

2
Lib/json/tests/test_pass1.py
View File

@ -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:

2
Lib/json/tests/test_pass2.py
View File

@ -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))

2
Lib/json/tests/test_pass3.py
View File

@ -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))

2
Lib/json/tests/test_recursion.py
View File

@ -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)

44
Lib/json/tests/test_scanstring.py
View File

@ -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))

6
Lib/json/tests/test_separators.py
View File

@ -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)

4
Lib/json/tests/test_speedups.py
View File

@ -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)

32
Lib/json/tests/test_unicode.py
View File

@ -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)

4
Lib/sqlite3/test/dbapi.py
View File

@ -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),

2
Lib/sqlite3/test/types.py
View File

@ -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):

48
Lib/test/buffer_tests.py
View File

@ -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)

6
Lib/test/fork_wait.py
View File

@ -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()

4
Lib/test/list_tests.py
View File

@ -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"

6
Lib/test/seq_tests.py
View File

@ -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])

22
Lib/test/string_tests.py
View File

@ -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)

10
Lib/test/test_SimpleHTTPServer.py
View File

@ -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():

8
Lib/test/test__locale.py
View File

@ -59,7 +59,7 @@ class _LocaleTests(unittest.TestCase):
known_value = known_numerics.get(used_locale,
('', ''))[data_type == 'thousands_sep']
if known_value and calc_value:
self.assertEquals(calc_value, known_value,
self.assertEqual(calc_value, known_value,
self.lc_numeric_err_msg % (
calc_value, known_value,
calc_type, data_type, set_locale,
@ -103,7 +103,7 @@ class _LocaleTests(unittest.TestCase):
set_locale = setlocale(LC_NUMERIC)
except Error:
set_locale = "<not able to determine>"
self.assertEquals(nl_radixchar, li_radixchar,
self.assertEqual(nl_radixchar, li_radixchar,
"%s (nl_langinfo) != %s (localeconv) "
"(set to %s, using %s)" % (
nl_radixchar, li_radixchar,
@ -122,9 +122,9 @@ class _LocaleTests(unittest.TestCase):
if loc == 'eu_ES' and localeconv()['decimal_point'] == "' ":
continue
self.assertEquals(int(eval('3.14') * 100), 314,
self.assertEqual(int(eval('3.14') * 100), 314,
"using eval('3.14') failed for %s" % loc)
self.assertEquals(int(float('3.14') * 100), 314,
self.assertEqual(int(float('3.14') * 100), 314,
"using float('3.14') failed for %s" % loc)
if localeconv()['decimal_point'] != '.':
self.assertRaises(ValueError, float,

18
Lib/test/test_argparse.py
View File

@ -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

4
Lib/test/test_array.py
View File

@ -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

20
Lib/test/test_ast.py
View File

@ -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):

24
Lib/test/test_augassign.py
View File

@ -19,10 +19,10 @@ class AugAssignTest(unittest.TestCase):
x /= 2
if 1/2 == 0:
# classic division
self.assertEquals(x, 3)
self.assertEqual(x, 3)
else:
# new-style division (with -Qnew)
self.assertEquals(x, 3.0)
self.assertEqual(x, 3.0)
def test_with_unpacking(self):
self.assertRaises(SyntaxError, compile, "x, b += 3", "<test>", "exec")
@ -40,9 +40,9 @@ class AugAssignTest(unittest.TestCase):
x[0] ^= 1
x[0] /= 2
if 1/2 == 0:
self.assertEquals(x[0], 3)
self.assertEqual(x[0], 3)
else:
self.assertEquals(x[0], 3.0)
self.assertEqual(x[0], 3.0)
def testInDict(self):
x = {0: 2}
@ -57,23 +57,23 @@ class AugAssignTest(unittest.TestCase):
x[0] ^= 1
x[0] /= 2
if 1/2 == 0:
self.assertEquals(x[0], 3)
self.assertEqual(x[0], 3)
else:
self.assertEquals(x[0], 3.0)
self.assertEqual(x[0], 3.0)
def testSequences(self):
x = [1,2]
x += [3,4]
x *= 2
self.assertEquals(x, [1, 2, 3, 4, 1, 2, 3, 4])
self.assertEqual(x, [1, 2, 3, 4, 1, 2, 3, 4])
x = [1, 2, 3]
y = x
x[1:2] *= 2
y[1:2] += [1]
self.assertEquals(x, [1, 2, 1, 2, 3])
self.assertEqual(x, [1, 2, 1, 2, 3])
self.assertTrue(x is y)
def testCustomMethods1(self):
@ -101,14 +101,14 @@ class AugAssignTest(unittest.TestCase):
self.assertIsInstance(x, aug_test)
self.assertTrue(y is not x)
self.assertEquals(x.val, 11)
self.assertEqual(x.val, 11)
x = aug_test2(2)
y = x
x += 10
self.assertTrue(y is x)
self.assertEquals(x.val, 12)
self.assertEqual(x.val, 12)
x = aug_test3(3)
y = x
@ -116,7 +116,7 @@ class AugAssignTest(unittest.TestCase):
self.assertIsInstance(x, aug_test3)
self.assertTrue(y is not x)
self.assertEquals(x.val, 13)
self.assertEqual(x.val, 13)
def testCustomMethods2(test_self):
@ -284,7 +284,7 @@ class AugAssignTest(unittest.TestCase):
1 << x
x <<= 1
test_self.assertEquals(output, '''\
test_self.assertEqual(output, '''\
__add__ called
__radd__ called
__iadd__ called

2
Lib/test/test_bigaddrspace.py
View File

@ -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)

492
Lib/test/test_bigmem.py
View File

@ -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)

14
Lib/test/test_builtin.py
View File

@ -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')

26
Lib/test/test_bytes.py
View File

@ -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

16
Lib/test/test_cfgparser.py
View File

@ -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():

4
Lib/test/test_cgi.py
View File

@ -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',

28
Lib/test/test_charmapcodec.py
View File

@ -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)

30
Lib/test/test_class.py
View File

@ -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.assertEqual(a1.f, a1.f)
self.assertNotEqual(a1.f, a2.f)
self.assertNotEqual(a1.f, a1.g)
self.assertEqual(a1.f, A(1).f)
self.assertEqual(hash(a1.f), hash(a1.f))
self.assertEqual(hash(a1.f), hash(A(1).f))
self.assertNotEquals(A.f, a1.f)
self.assertNotEquals(A.f, A.g)
self.assertEquals(B.f, A.f)
self.assertEquals(hash(B.f), hash(A.f))
self.assertNotEqual(A.f, a1.f)
self.assertNotEqual(A.f, A.g)
self.assertEqual(B.f, A.f)
self.assertEqual(hash(B.f), hash(A.f))
# the following triggers a SystemError in 2.4
a = A(hash(A.f.im_func)^(-1))

6
Lib/test/test_code.py
View File

@ -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):

62
Lib/test/test_codeccallbacks.py
View File

@ -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

138
Lib/test/test_codecs.py
View File

@ -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():

26
Lib/test/test_codeop.py
View File

@ -37,14 +37,14 @@ class CodeopTests(unittest.TestCase):
ctx = {'a': 2}
d = { 'value': eval(code,ctx) }
r = { 'value': eval(str,ctx) }
self.assertEquals(unify_callables(r),unify_callables(d))
self.assertEqual(unify_callables(r),unify_callables(d))
else:
expected = compile(str, "<input>", symbol, PyCF_DONT_IMPLY_DEDENT)
self.assertEquals( compile_command(str, "<input>", symbol), expected)
self.assertEqual(compile_command(str, "<input>", symbol), expected)
def assertIncomplete(self, str, symbol='single'):
'''succeed iff str is the start of a valid piece of code'''
self.assertEquals( compile_command(str, symbol=symbol), None)
self.assertEqual(compile_command(str, symbol=symbol), None)
def assertInvalid(self, str, symbol='single', is_syntax=1):
'''succeed iff str is the start of an invalid piece of code'''
@ -61,12 +61,12 @@ class CodeopTests(unittest.TestCase):
# special case
if not is_jython:
self.assertEquals(compile_command(""),
compile("pass", "<input>", 'single',
PyCF_DONT_IMPLY_DEDENT))
self.assertEquals(compile_command("\n"),
compile("pass", "<input>", 'single',
PyCF_DONT_IMPLY_DEDENT))
self.assertEqual(compile_command(""),
compile("pass", "<input>", 'single',
PyCF_DONT_IMPLY_DEDENT))
self.assertEqual(compile_command("\n"),
compile("pass", "<input>", 'single',
PyCF_DONT_IMPLY_DEDENT))
else:
av("")
av("\n")
@ -290,10 +290,10 @@ class CodeopTests(unittest.TestCase):
ai("[i for i in range(10)] = (1, 2, 3)")
def test_filename(self):
self.assertEquals(compile_command("a = 1\n", "abc").co_filename,
compile("a = 1\n", "abc", 'single').co_filename)
self.assertNotEquals(compile_command("a = 1\n", "abc").co_filename,
compile("a = 1\n", "def", 'single').co_filename)
self.assertEqual(compile_command("a = 1\n", "abc").co_filename,
compile("a = 1\n", "abc", 'single').co_filename)
self.assertNotEqual(compile_command("a = 1\n", "abc").co_filename,
compile("a = 1\n", "def", 'single').co_filename)
def test_main():

22
Lib/test/test_coercion.py
View File

@ -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

14
Lib/test/test_collections.py
View File

@ -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.

6
Lib/test/test_commands.py
View File

@ -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)

46
Lib/test/test_compiler.py
View File

@ -81,8 +81,8 @@ class CompilerTest(unittest.TestCase):
"<string>", "exec")
dct = {}
exec c in dct
self.assertEquals(dct.get('e'), 1)
self.assertEquals(dct.get('f'), 1)
self.assertEqual(dct.get('e'), 1)
self.assertEqual(dct.get('f'), 1)
def testDefaultArgs(self):
self.assertRaises(SyntaxError, compiler.parse, "def foo(a=1, b): pass")
@ -93,7 +93,7 @@ class CompilerTest(unittest.TestCase):
c = compiler.compile('def f():\n "doc"', '<string>', 'exec')
g = {}
exec c in g
self.assertEquals(g['f'].__doc__, "doc")
self.assertEqual(g['f'].__doc__, "doc")
def testLineNo(self):
# Test that all nodes except Module have a correct lineno attribute.
@ -120,8 +120,8 @@ class CompilerTest(unittest.TestCase):
self.check_lineno(child)
def testFlatten(self):
self.assertEquals(flatten([1, [2]]), [1, 2])
self.assertEquals(flatten((1, (2,))), [1, 2])
self.assertEqual(flatten([1, [2]]), [1, 2])
self.assertEqual(flatten((1, (2,))), [1, 2])
def testNestedScope(self):
c = compiler.compile('def g():\n'
@ -133,44 +133,44 @@ class CompilerTest(unittest.TestCase):
'exec')
dct = {}
exec c in dct
self.assertEquals(dct.get('result'), 3)
self.assertEqual(dct.get('result'), 3)
def testGenExp(self):
c = compiler.compile('list((i,j) for i in range(3) if i < 3'
' for j in range(4) if j > 2)',
'<string>',
'eval')
self.assertEquals(eval(c), [(0, 3), (1, 3), (2, 3)])
self.assertEqual(eval(c), [(0, 3), (1, 3), (2, 3)])
def testSetLiteral(self):
c = compiler.compile('{1, 2, 3}', '<string>', 'eval')
self.assertEquals(eval(c), {1,2,3})
self.assertEqual(eval(c), {1,2,3})
c = compiler.compile('{1, 2, 3,}', '<string>', 'eval')
self.assertEquals(eval(c), {1,2,3})
self.assertEqual(eval(c), {1,2,3})
def testDictLiteral(self):
c = compiler.compile('{1:2, 2:3, 3:4}', '<string>', 'eval')
self.assertEquals(eval(c), {1:2, 2:3, 3:4})
self.assertEqual(eval(c), {1:2, 2:3, 3:4})
c = compiler.compile('{1:2, 2:3, 3:4,}', '<string>', 'eval')
self.assertEquals(eval(c), {1:2, 2:3, 3:4})
self.assertEqual(eval(c), {1:2, 2:3, 3:4})
def testSetComp(self):
c = compiler.compile('{x for x in range(1, 4)}', '<string>', 'eval')
self.assertEquals(eval(c), {1, 2, 3})
self.assertEqual(eval(c), {1, 2, 3})
c = compiler.compile('{x * y for x in range(3) if x != 0'
' for y in range(4) if y != 0}',
'<string>',
'eval')
self.assertEquals(eval(c), {1, 2, 3, 4, 6})
self.assertEqual(eval(c), {1, 2, 3, 4, 6})
def testDictComp(self):
c = compiler.compile('{x:x+1 for x in range(1, 4)}', '<string>', 'eval')
self.assertEquals(eval(c), {1:2, 2:3, 3:4})
self.assertEqual(eval(c), {1:2, 2:3, 3:4})
c = compiler.compile('{(x, y) : y for x in range(2) if x != 0'
' for y in range(3) if y != 0}',
'<string>',
'eval')
self.assertEquals(eval(c), {(1, 2): 2, (1, 1): 1})
self.assertEqual(eval(c), {(1, 2): 2, (1, 1): 1})
def testWith(self):
# SF bug 1638243
@ -183,7 +183,7 @@ class CompilerTest(unittest.TestCase):
'exec' )
dct = {'TrivialContext': TrivialContext}
exec c in dct
self.assertEquals(dct.get('result'), 1)
self.assertEqual(dct.get('result'), 1)
def testWithAss(self):
c = compiler.compile('from __future__ import with_statement\n'
@ -195,7 +195,7 @@ class CompilerTest(unittest.TestCase):
'exec' )
dct = {'TrivialContext': TrivialContext}
exec c in dct
self.assertEquals(dct.get('result'), 1)
self.assertEqual(dct.get('result'), 1)
def testWithMult(self):
events = []
@ -215,8 +215,8 @@ class CompilerTest(unittest.TestCase):
'exec' )
dct = {'Ctx': Ctx}
exec c in dct
self.assertEquals(dct.get('result'), 1)
self.assertEquals(events, [1, 2])
self.assertEqual(dct.get('result'), 1)
self.assertEqual(events, [1, 2])
def testGlobal(self):
code = compiler.compile('global x\nx=1', '<string>', 'exec')
@ -224,7 +224,7 @@ class CompilerTest(unittest.TestCase):
d2 = {}
exec code in d1, d2
# x should be in the globals dict
self.assertEquals(d1.get('x'), 1)
self.assertEqual(d1.get('x'), 1)
def testPrintFunction(self):
c = compiler.compile('from __future__ import print_function\n'
@ -234,14 +234,14 @@ class CompilerTest(unittest.TestCase):
'exec' )
dct = {'output': StringIO()}
exec c in dct
self.assertEquals(dct['output'].getvalue(), 'a**b++')
self.assertEqual(dct['output'].getvalue(), 'a**b++')
def _testErrEnc(self, src, text, offset):
try:
compile(src, "", "exec")
except SyntaxError, e:
self.assertEquals(e.offset, offset)
self.assertEquals(e.text, text)
self.assertEqual(e.offset, offset)
self.assertEqual(e.text, text)
def testSourceCodeEncodingsError(self):
# Test SyntaxError with encoding definition

4
Lib/test/test_complex.py
View File

@ -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")

262
Lib/test/test_cookielib.py
View File

@ -18,10 +18,10 @@ class DateTimeTests(TestCase):
base = 1019227000
day = 24*3600
self.assertEquals(time2isoz(base), "2002-04-19 14:36:40Z")
self.assertEquals(time2isoz(base+day), "2002-04-20 14:36:40Z")
self.assertEquals(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
self.assertEquals(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
self.assertEqual(time2isoz(base), "2002-04-19 14:36:40Z")
self.assertEqual(time2isoz(base+day), "2002-04-20 14:36:40Z")
self.assertEqual(time2isoz(base+2*day), "2002-04-21 14:36:40Z")
self.assertEqual(time2isoz(base+3*day), "2002-04-22 14:36:40Z")
az = time2isoz()
bz = time2isoz(500000)
@ -35,13 +35,13 @@ class DateTimeTests(TestCase):
def parse_date(text):
return time.gmtime(http2time(text))[:6]
self.assertEquals(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
self.assertEqual(parse_date("01 Jan 2001"), (2001, 1, 1, 0, 0, 0.0))
# this test will break around year 2070
self.assertEquals(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
self.assertEqual(parse_date("03-Feb-20"), (2020, 2, 3, 0, 0, 0.0))
# this test will break around year 2048
self.assertEquals(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
self.assertEqual(parse_date("03-Feb-98"), (1998, 2, 3, 0, 0, 0.0))
def test_http2time_formats(self):
from cookielib import http2time, time2isoz
@ -71,8 +71,8 @@ class DateTimeTests(TestCase):
test_t = 760233600 # assume broken POSIX counting of seconds
result = time2isoz(test_t)
expected = "1994-02-03 00:00:00Z"
self.assertEquals(result, expected,
"%s => '%s' (%s)" % (test_t, result, expected))
self.assertEqual(result, expected,
"%s => '%s' (%s)" % (test_t, result, expected))
for s in tests:
t = http2time(s)
@ -114,7 +114,7 @@ class HeaderTests(TestCase):
'foo=bar; expires=01 Jan 2040 22:23:32 GMT',
'foo=bar; expires="01 Jan 2040 22:23:32 GMT"',
]:
self.assertEquals(parse_ns_headers([hdr]), expected)
self.assertEqual(parse_ns_headers([hdr]), expected)
def test_parse_ns_headers_version(self):
from cookielib import parse_ns_headers
@ -125,7 +125,7 @@ class HeaderTests(TestCase):
'foo=bar; version="1"',
'foo=bar; Version="1"',
]:
self.assertEquals(parse_ns_headers([hdr]), expected)
self.assertEqual(parse_ns_headers([hdr]), expected)
def test_parse_ns_headers_special_names(self):
# names such as 'expires' are not special in first name=value pair
@ -135,15 +135,15 @@ class HeaderTests(TestCase):
# Cookie with name 'expires'
hdr = 'expires=01 Jan 2040 22:23:32 GMT'
expected = [[("expires", "01 Jan 2040 22:23:32 GMT"), ("version", "0")]]
self.assertEquals(parse_ns_headers([hdr]), expected)
self.assertEqual(parse_ns_headers([hdr]), expected)
def test_join_header_words(self):
from cookielib import join_header_words
joined = join_header_words([[("foo", None), ("bar", "baz")]])
self.assertEquals(joined, "foo; bar=baz")
self.assertEqual(joined, "foo; bar=baz")
self.assertEquals(join_header_words([[]]), "")
self.assertEqual(join_header_words([[]]), "")
def test_split_header_words(self):
from cookielib import split_header_words
@ -175,7 +175,7 @@ class HeaderTests(TestCase):
f = StringIO.StringIO()
traceback.print_exc(None, f)
result = "(error -- traceback follows)\n\n%s" % f.getvalue()
self.assertEquals(result, expect, """
self.assertEqual(result, expect, """
When parsing: '%s'
Expected: '%s'
Got: '%s'
@ -209,7 +209,7 @@ Got: '%s'
for arg, expect in tests:
input = split_header_words([arg])
res = join_header_words(input)
self.assertEquals(res, expect, """
self.assertEqual(res, expect, """
When parsing: '%s'
Expected: '%s'
Got: '%s'
@ -380,11 +380,11 @@ class CookieTests(TestCase):
interact_netscape(c, "http://www.acme.com/", '"spam"; path=/foo/')
cookie = c._cookies["www.acme.com"]["/"]["eggs"]
self.assertTrue(cookie.value is None)
self.assertEquals(cookie.name, "eggs")
self.assertEqual(cookie.name, "eggs")
cookie = c._cookies["www.acme.com"]['/foo/']['"spam"']
self.assertTrue(cookie.value is None)
self.assertEquals(cookie.name, '"spam"')
self.assertEquals(lwp_cookie_str(cookie), (
self.assertEqual(cookie.name, '"spam"')
self.assertEqual(lwp_cookie_str(cookie), (
r'"spam"; path="/foo/"; domain="www.acme.com"; '
'path_spec; discard; version=0'))
old_str = repr(c)
@ -395,13 +395,13 @@ class CookieTests(TestCase):
finally:
os.unlink(c.filename)
# cookies unchanged apart from lost info re. whether path was specified
self.assertEquals(
self.assertEqual(
repr(c),
re.sub("path_specified=%s" % True, "path_specified=%s" % False,
old_str)
)
self.assertEquals(interact_netscape(c, "http://www.acme.com/foo/"),
'"spam"; eggs')
self.assertEqual(interact_netscape(c, "http://www.acme.com/foo/"),
'"spam"; eggs')
def test_rfc2109_handling(self):
# RFC 2109 cookies are handled as RFC 2965 or Netscape cookies,
@ -449,18 +449,18 @@ class CookieTests(TestCase):
'expires="Foo Bar 25 33:22:11 3022"')
cookie = c._cookies[".acme.com"]["/"]["spam"]
self.assertEquals(cookie.domain, ".acme.com")
self.assertEqual(cookie.domain, ".acme.com")
self.assertTrue(cookie.domain_specified)
self.assertEquals(cookie.port, DEFAULT_HTTP_PORT)
self.assertEqual(cookie.port, DEFAULT_HTTP_PORT)
self.assertTrue(not cookie.port_specified)
# case is preserved
self.assertTrue(cookie.has_nonstandard_attr("blArgh") and
not cookie.has_nonstandard_attr("blargh"))
cookie = c._cookies["www.acme.com"]["/"]["ni"]
self.assertEquals(cookie.domain, "www.acme.com")
self.assertEqual(cookie.domain, "www.acme.com")
self.assertTrue(not cookie.domain_specified)
self.assertEquals(cookie.port, "80,8080")
self.assertEqual(cookie.port, "80,8080")
self.assertTrue(cookie.port_specified)
cookie = c._cookies["www.acme.com"]["/"]["nini"]
@ -494,13 +494,13 @@ class CookieTests(TestCase):
future = time2netscape(time.time()+3600)
interact_netscape(c, "http://www.acme.com/", 'spam="bar"; expires=%s' %
future)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
now = time2netscape(time.time()-1)
# ... and if in past or present, discard it
interact_netscape(c, "http://www.acme.com/", 'foo="eggs"; expires=%s' %
now)
h = interact_netscape(c, "http://www.acme.com/")
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
self.assertTrue('spam="bar"' in h and "foo" not in h)
# max-age takes precedence over expires, and zero max-age is request to
@ -509,19 +509,19 @@ class CookieTests(TestCase):
future)
interact_netscape(c, "http://www.acme.com/", 'bar="bar"; expires=%s' %
future)
self.assertEquals(len(c), 3)
self.assertEqual(len(c), 3)
interact_netscape(c, "http://www.acme.com/", 'eggs="bar"; '
'expires=%s; max-age=0' % future)
interact_netscape(c, "http://www.acme.com/", 'bar="bar"; '
'max-age=0; expires=%s' % future)
h = interact_netscape(c, "http://www.acme.com/")
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
# test expiry at end of session for cookies with no expires attribute
interact_netscape(c, "http://www.rhubarb.net/", 'whum="fizz"')
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
c.clear_session_cookies()
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
self.assertIn('spam="bar"', h)
# XXX RFC 2965 expiry rules (some apply to V0 too)
@ -576,7 +576,7 @@ class CookieTests(TestCase):
# default path does not include query, so is "/", not "/?spam"
self.assertIn("/", cj._cookies["example.com"])
# cookie is sent back to the same URI
self.assertEquals(interact_netscape(cj, uri), value)
self.assertEqual(interact_netscape(cj, uri), value)
def test_escape_path(self):
from cookielib import escape_path
@ -600,7 +600,7 @@ class CookieTests(TestCase):
(u"/foo/bar\uabcd", "/foo/bar%EA%AF%8D"), # UTF-8 encoded
]
for arg, result in cases:
self.assertEquals(escape_path(arg), result)
self.assertEqual(escape_path(arg), result)
def test_request_path(self):
from urllib2 import Request
@ -608,25 +608,25 @@ class CookieTests(TestCase):
# with parameters
req = Request("http://www.example.com/rheum/rhaponticum;"
"foo=bar;sing=song?apples=pears&spam=eggs#ni")
self.assertEquals(request_path(req),
"/rheum/rhaponticum;foo=bar;sing=song")
self.assertEqual(request_path(req),
"/rheum/rhaponticum;foo=bar;sing=song")
# without parameters
req = Request("http://www.example.com/rheum/rhaponticum?"
"apples=pears&spam=eggs#ni")
self.assertEquals(request_path(req), "/rheum/rhaponticum")
self.assertEqual(request_path(req), "/rheum/rhaponticum")
# missing final slash
req = Request("http://www.example.com")
self.assertEquals(request_path(req), "/")
self.assertEqual(request_path(req), "/")
def test_request_port(self):
from urllib2 import Request
from cookielib import request_port, DEFAULT_HTTP_PORT
req = Request("http://www.acme.com:1234/",
headers={"Host": "www.acme.com:4321"})
self.assertEquals(request_port(req), "1234")
self.assertEqual(request_port(req), "1234")
req = Request("http://www.acme.com/",
headers={"Host": "www.acme.com:4321"})
self.assertEquals(request_port(req), DEFAULT_HTTP_PORT)
self.assertEqual(request_port(req), DEFAULT_HTTP_PORT)
def test_request_host(self):
from urllib2 import Request
@ -636,20 +636,20 @@ class CookieTests(TestCase):
headers={"Host": "www.acme.com:80"})
# libwww-perl wants this response, but that seems wrong (RFC 2616,
# section 5.2, point 1., and RFC 2965 section 1, paragraph 3)
#self.assertEquals(request_host(req), "www.acme.com")
self.assertEquals(request_host(req), "1.1.1.1")
#self.assertEqual(request_host(req), "www.acme.com")
self.assertEqual(request_host(req), "1.1.1.1")
req = Request("http://www.acme.com/",
headers={"Host": "irrelevant.com"})
self.assertEquals(request_host(req), "www.acme.com")
self.assertEqual(request_host(req), "www.acme.com")
# not actually sure this one is valid Request object, so maybe should
# remove test for no host in url in request_host function?
req = Request("/resource.html",
headers={"Host": "www.acme.com"})
self.assertEquals(request_host(req), "www.acme.com")
self.assertEqual(request_host(req), "www.acme.com")
# port shouldn't be in request-host
req = Request("http://www.acme.com:2345/resource.html",
headers={"Host": "www.acme.com:5432"})
self.assertEquals(request_host(req), "www.acme.com")
self.assertEqual(request_host(req), "www.acme.com")
def test_is_HDN(self):
from cookielib import is_HDN
@ -664,14 +664,14 @@ class CookieTests(TestCase):
def test_reach(self):
from cookielib import reach
self.assertEquals(reach("www.acme.com"), ".acme.com")
self.assertEquals(reach("acme.com"), "acme.com")
self.assertEquals(reach("acme.local"), ".local")
self.assertEquals(reach(".local"), ".local")
self.assertEquals(reach(".com"), ".com")
self.assertEquals(reach("."), ".")
self.assertEquals(reach(""), "")
self.assertEquals(reach("192.168.0.1"), "192.168.0.1")
self.assertEqual(reach("www.acme.com"), ".acme.com")
self.assertEqual(reach("acme.com"), "acme.com")
self.assertEqual(reach("acme.local"), ".local")
self.assertEqual(reach(".local"), ".local")
self.assertEqual(reach(".com"), ".com")
self.assertEqual(reach("."), ".")
self.assertEqual(reach(""), "")
self.assertEqual(reach("192.168.0.1"), "192.168.0.1")
def test_domain_match(self):
from cookielib import domain_match, user_domain_match
@ -719,7 +719,7 @@ class CookieTests(TestCase):
c = CookieJar()
interact_2965(c, "http://www.nasty.com/",
'foo=bar; domain=friendly.org; Version="1"')
self.assertEquals(len(c), 0)
self.assertEqual(len(c), 0)
def test_strict_domain(self):
# Cookies whose domain is a country-code tld like .co.uk should
@ -731,11 +731,11 @@ class CookieTests(TestCase):
interact_netscape(cj, "http://example.co.uk/", 'no=problemo')
interact_netscape(cj, "http://example.co.uk/",
'okey=dokey; Domain=.example.co.uk')
self.assertEquals(len(cj), 2)
self.assertEqual(len(cj), 2)
for pseudo_tld in [".co.uk", ".org.za", ".tx.us", ".name.us"]:
interact_netscape(cj, "http://example.%s/" % pseudo_tld,
'spam=eggs; Domain=.co.uk')
self.assertEquals(len(cj), 2)
self.assertEqual(len(cj), 2)
def test_two_component_domain_ns(self):
# Netscape: .www.bar.com, www.bar.com, .bar.com, bar.com, no domain
@ -747,17 +747,17 @@ class CookieTests(TestCase):
# two-component V0 domain is OK
interact_netscape(c, "http://foo.net/", 'ns=bar')
self.assertEquals(len(c), 1)
self.assertEquals(c._cookies["foo.net"]["/"]["ns"].value, "bar")
self.assertEquals(interact_netscape(c, "http://foo.net/"), "ns=bar")
self.assertEqual(len(c), 1)
self.assertEqual(c._cookies["foo.net"]["/"]["ns"].value, "bar")
self.assertEqual(interact_netscape(c, "http://foo.net/"), "ns=bar")
# *will* be returned to any other domain (unlike RFC 2965)...
self.assertEquals(interact_netscape(c, "http://www.foo.net/"),
"ns=bar")
self.assertEqual(interact_netscape(c, "http://www.foo.net/"),
"ns=bar")
# ...unless requested otherwise
pol = DefaultCookiePolicy(
strict_ns_domain=DefaultCookiePolicy.DomainStrictNonDomain)
c.set_policy(pol)
self.assertEquals(interact_netscape(c, "http://www.foo.net/"), "")
self.assertEqual(interact_netscape(c, "http://www.foo.net/"), "")
# unlike RFC 2965, even explicit two-component domain is OK,
# because .foo.net matches foo.net
@ -766,17 +766,17 @@ class CookieTests(TestCase):
# even if starts with a dot -- in NS rules, .foo.net matches foo.net!
interact_netscape(c, "http://foo.net/foo/bar/",
'spam2=eggs; domain=.foo.net')
self.assertEquals(len(c), 3)
self.assertEquals(c._cookies[".foo.net"]["/foo"]["spam1"].value,
"eggs")
self.assertEquals(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
"eggs")
self.assertEquals(interact_netscape(c, "http://foo.net/foo/bar/"),
"spam2=eggs; spam1=eggs; ns=bar")
self.assertEqual(len(c), 3)
self.assertEqual(c._cookies[".foo.net"]["/foo"]["spam1"].value,
"eggs")
self.assertEqual(c._cookies[".foo.net"]["/foo/bar"]["spam2"].value,
"eggs")
self.assertEqual(interact_netscape(c, "http://foo.net/foo/bar/"),
"spam2=eggs; spam1=eggs; ns=bar")
# top-level domain is too general
interact_netscape(c, "http://foo.net/", 'nini="ni"; domain=.net')
self.assertEquals(len(c), 3)
self.assertEqual(len(c), 3)
## # Netscape protocol doesn't allow non-special top level domains (such
## # as co.uk) in the domain attribute unless there are at least three
@ -784,8 +784,8 @@ class CookieTests(TestCase):
# Oh yes it does! Real implementations don't check this, and real
# cookies (of course) rely on that behaviour.
interact_netscape(c, "http://foo.co.uk", 'nasty=trick; domain=.co.uk')
## self.assertEquals(len(c), 2)
self.assertEquals(len(c), 4)
## self.assertEqual(len(c), 2)
self.assertEqual(len(c), 4)
def test_two_component_domain_rfc2965(self):
from cookielib import CookieJar, DefaultCookiePolicy
@ -795,43 +795,43 @@ class CookieTests(TestCase):
# two-component V1 domain is OK
interact_2965(c, "http://foo.net/", 'foo=bar; Version="1"')
self.assertEquals(len(c), 1)
self.assertEquals(c._cookies["foo.net"]["/"]["foo"].value, "bar")
self.assertEquals(interact_2965(c, "http://foo.net/"),
"$Version=1; foo=bar")
self.assertEqual(len(c), 1)
self.assertEqual(c._cookies["foo.net"]["/"]["foo"].value, "bar")
self.assertEqual(interact_2965(c, "http://foo.net/"),
"$Version=1; foo=bar")
# won't be returned to any other domain (because domain was implied)
self.assertEquals(interact_2965(c, "http://www.foo.net/"), "")
self.assertEqual(interact_2965(c, "http://www.foo.net/"), "")
# unless domain is given explicitly, because then it must be
# rewritten to start with a dot: foo.net --> .foo.net, which does
# not domain-match foo.net
interact_2965(c, "http://foo.net/foo",
'spam=eggs; domain=foo.net; path=/foo; Version="1"')
self.assertEquals(len(c), 1)
self.assertEquals(interact_2965(c, "http://foo.net/foo"),
"$Version=1; foo=bar")
self.assertEqual(len(c), 1)
self.assertEqual(interact_2965(c, "http://foo.net/foo"),
"$Version=1; foo=bar")
# explicit foo.net from three-component domain www.foo.net *does* get
# set, because .foo.net domain-matches .foo.net
interact_2965(c, "http://www.foo.net/foo/",
'spam=eggs; domain=foo.net; Version="1"')
self.assertEquals(c._cookies[".foo.net"]["/foo/"]["spam"].value,
"eggs")
self.assertEquals(len(c), 2)
self.assertEquals(interact_2965(c, "http://foo.net/foo/"),
"$Version=1; foo=bar")
self.assertEquals(interact_2965(c, "http://www.foo.net/foo/"),
'$Version=1; spam=eggs; $Domain="foo.net"')
self.assertEqual(c._cookies[".foo.net"]["/foo/"]["spam"].value,
"eggs")
self.assertEqual(len(c), 2)
self.assertEqual(interact_2965(c, "http://foo.net/foo/"),
"$Version=1; foo=bar")
self.assertEqual(interact_2965(c, "http://www.foo.net/foo/"),
'$Version=1; spam=eggs; $Domain="foo.net"')
# top-level domain is too general
interact_2965(c, "http://foo.net/",
'ni="ni"; domain=".net"; Version="1"')
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
# RFC 2965 doesn't require blocking this
interact_2965(c, "http://foo.co.uk/",
'nasty=trick; domain=.co.uk; Version="1"')
self.assertEquals(len(c), 3)
self.assertEqual(len(c), 3)
def test_domain_allow(self):
from cookielib import CookieJar, DefaultCookiePolicy
@ -845,24 +845,24 @@ class CookieTests(TestCase):
headers = ["Set-Cookie: CUSTOMER=WILE_E_COYOTE; path=/"]
res = FakeResponse(headers, "http://acme.com/")
c.extract_cookies(res, req)
self.assertEquals(len(c), 0)
self.assertEqual(len(c), 0)
req = Request("http://www.acme.com/")
res = FakeResponse(headers, "http://www.acme.com/")
c.extract_cookies(res, req)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
req = Request("http://www.coyote.com/")
res = FakeResponse(headers, "http://www.coyote.com/")
c.extract_cookies(res, req)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
# set a cookie with non-allowed domain...
req = Request("http://www.coyote.com/")
res = FakeResponse(headers, "http://www.coyote.com/")
cookies = c.make_cookies(res, req)
c.set_cookie(cookies[0])
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
# ... and check is doesn't get returned
c.add_cookie_header(req)
self.assertTrue(not req.has_header("Cookie"))
@ -879,17 +879,17 @@ class CookieTests(TestCase):
req = Request("http://www.acme.com/")
res = FakeResponse(headers, "http://www.acme.com/")
c.extract_cookies(res, req)
self.assertEquals(len(c), 0)
self.assertEqual(len(c), 0)
p = pol.set_blocked_domains(["acme.com"])
c.extract_cookies(res, req)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
c.clear()
req = Request("http://www.roadrunner.net/")
res = FakeResponse(headers, "http://www.roadrunner.net/")
c.extract_cookies(res, req)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
req = Request("http://www.roadrunner.net/")
c.add_cookie_header(req)
self.assertTrue((req.has_header("Cookie") and
@ -898,14 +898,14 @@ class CookieTests(TestCase):
c.clear()
pol.set_blocked_domains([".acme.com"])
c.extract_cookies(res, req)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
# set a cookie with blocked domain...
req = Request("http://www.acme.com/")
res = FakeResponse(headers, "http://www.acme.com/")
cookies = c.make_cookies(res, req)
c.set_cookie(cookies[0])
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
# ... and check is doesn't get returned
c.add_cookie_header(req)
self.assertTrue(not req.has_header("Cookie"))
@ -940,7 +940,7 @@ class CookieTests(TestCase):
c = CookieJar(policy=DefaultCookiePolicy(rfc2965=True))
interact_2965(c, "http://www.acme.com/", r'foo=\b"a"r; Version=1')
h = interact_2965(c, "http://www.acme.com/")
self.assertEquals(h, r'$Version=1; foo=\\b\"a\"r')
self.assertEqual(h, r'$Version=1; foo=\\b\"a\"r')
def test_missing_final_slash(self):
# Missing slash from request URL's abs_path should be assumed present.
@ -950,7 +950,7 @@ class CookieTests(TestCase):
c = CookieJar(DefaultCookiePolicy(rfc2965=True))
interact_2965(c, url, "foo=bar; Version=1")
req = Request(url)
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
c.add_cookie_header(req)
self.assertTrue(req.has_header("Cookie"))
@ -1070,33 +1070,33 @@ class CookieTests(TestCase):
i = 0
for c in cs:
self.assertIsInstance(c, Cookie)
self.assertEquals(c.version, versions[i])
self.assertEquals(c.name, names[i])
self.assertEquals(c.domain, domains[i])
self.assertEquals(c.path, paths[i])
self.assertEqual(c.version, versions[i])
self.assertEqual(c.name, names[i])
self.assertEqual(c.domain, domains[i])
self.assertEqual(c.path, paths[i])
i = i + 1
def test_parse_ns_headers(self):
from cookielib import parse_ns_headers
# missing domain value (invalid cookie)
self.assertEquals(
self.assertEqual(
parse_ns_headers(["foo=bar; path=/; domain"]),
[[("foo", "bar"),
("path", "/"), ("domain", None), ("version", "0")]]
)
# invalid expires value
self.assertEquals(
self.assertEqual(
parse_ns_headers(["foo=bar; expires=Foo Bar 12 33:22:11 2000"]),
[[("foo", "bar"), ("expires", None), ("version", "0")]]
)
# missing cookie value (valid cookie)
self.assertEquals(
self.assertEqual(
parse_ns_headers(["foo"]),
[[("foo", None), ("version", "0")]]
)
# shouldn't add version if header is empty
self.assertEquals(parse_ns_headers([""]), [])
self.assertEqual(parse_ns_headers([""]), [])
def test_bad_cookie_header(self):
@ -1122,7 +1122,7 @@ class CookieTests(TestCase):
]:
c = cookiejar_from_cookie_headers(headers)
# these bad cookies shouldn't be set
self.assertEquals(len(c), 0)
self.assertEqual(len(c), 0)
# cookie with invalid expires is treated as session cookie
headers = ["Set-Cookie: c=foo; expires=Foo Bar 12 33:22:11 2000"]
@ -1267,7 +1267,7 @@ class LWPCookieTests(TestCase):
req = Request("http://www.acme.com/")
c.add_cookie_header(req)
self.assertEquals(req.get_header("Cookie"),
self.assertEqual(req.get_header("Cookie"),
"PART_NUMBER=ROCKET_LAUNCHER_0001")
headers.append(
@ -1471,40 +1471,40 @@ class LWPCookieTests(TestCase):
# legal domain
cookie = interact_2965(c, "http://www.acme.com",
'ping=pong; domain="acme.com"; version=1')
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
# illegal domain (host prefix "www.a" contains a dot)
cookie = interact_2965(c, "http://www.a.acme.com",
'whiz=bang; domain="acme.com"; version=1')
self.assertEquals(len(c), 1)
self.assertEqual(len(c), 1)
# legal domain
cookie = interact_2965(c, "http://www.a.acme.com",
'wow=flutter; domain=".a.acme.com"; version=1')
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
# can't partially match an IP-address
cookie = interact_2965(c, "http://125.125.125.125",
'zzzz=ping; domain="125.125.125"; version=1')
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
# illegal path (must be prefix of request path)
cookie = interact_2965(c, "http://www.sol.no",
'blah=rhubarb; domain=".sol.no"; path="/foo"; '
'version=1')
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
# legal path
cookie = interact_2965(c, "http://www.sol.no/foo/bar",
'bing=bong; domain=".sol.no"; path="/foo"; '
'version=1')
self.assertEquals(len(c), 3)
self.assertEqual(len(c), 3)
# illegal port (request-port not in list)
cookie = interact_2965(c, "http://www.sol.no",
'whiz=ffft; domain=".sol.no"; port="90,100"; '
'version=1')
self.assertEquals(len(c), 3)
self.assertEqual(len(c), 3)
# legal port
cookie = interact_2965(
@ -1512,13 +1512,13 @@ class LWPCookieTests(TestCase):
r'bang=wallop; version=1; domain=".sol.no"; '
r'port="90,100, 80,8080"; '
r'max-age=100; Comment = "Just kidding! (\"|\\\\) "')
self.assertEquals(len(c), 4)
self.assertEqual(len(c), 4)
# port attribute without any value (current port)
cookie = interact_2965(c, "http://www.sol.no",
'foo9=bar; version=1; domain=".sol.no"; port; '
'max-age=100;')
self.assertEquals(len(c), 5)
self.assertEqual(len(c), 5)
# encoded path
# LWP has this test, but unescaping allowed path characters seems
@ -1529,7 +1529,7 @@ class LWPCookieTests(TestCase):
# character:
cookie = interact_2965(c, "http://www.sol.no/<oo/",
r'foo8=bar; version=1; path="/%3coo"')
self.assertEquals(len(c), 6)
self.assertEqual(len(c), 6)
# save and restore
filename = test_support.TESTFN
@ -1544,7 +1544,7 @@ class LWPCookieTests(TestCase):
try: os.unlink(filename)
except OSError: pass
self.assertEquals(old, repr(c))
self.assertEqual(old, repr(c))
def test_url_encoding(self):
# Try some URL encodings of the PATHs.
@ -1604,11 +1604,11 @@ class LWPCookieTests(TestCase):
return new_c
new_c = save_and_restore(c, True)
self.assertEquals(len(new_c), 6) # none discarded
self.assertEqual(len(new_c), 6) # none discarded
self.assertIn("name='foo1', value='bar'", repr(new_c))
new_c = save_and_restore(c, False)
self.assertEquals(len(new_c), 4) # 2 of them discarded on save
self.assertEqual(len(new_c), 4) # 2 of them discarded on save
self.assertIn("name='foo1', value='bar'", repr(new_c))
def test_netscape_misc(self):
@ -1661,12 +1661,12 @@ class LWPCookieTests(TestCase):
interact_netscape(c, "http://example/", "foo1=bar")
cookie = interact_netscape(c, "http://example/",
'foo2=bar; domain=.local')
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
self.assertIn("foo1=bar", cookie)
cookie = interact_netscape(c, "http://example/")
self.assertIn("foo2=bar", cookie)
self.assertEquals(len(c), 2)
self.assertEqual(len(c), 2)
def test_empty_path(self):
from cookielib import CookieJar, DefaultCookiePolicy
@ -1690,17 +1690,17 @@ class LWPCookieTests(TestCase):
req = Request("http://www.ants.com/")
c.add_cookie_header(req)
self.assertEquals(req.get_header("Cookie"),
"JSESSIONID=ABCDERANDOM123")
self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
self.assertEqual(req.get_header("Cookie"),
"JSESSIONID=ABCDERANDOM123")
self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
# missing path in the request URI
req = Request("http://www.ants.com:8080")
c.add_cookie_header(req)
self.assertEquals(req.get_header("Cookie"),
"JSESSIONID=ABCDERANDOM123")
self.assertEquals(req.get_header("Cookie2"), '$Version="1"')
self.assertEqual(req.get_header("Cookie"),
"JSESSIONID=ABCDERANDOM123")
self.assertEqual(req.get_header("Cookie2"), '$Version="1"')
def test_session_cookies(self):
from cookielib import CookieJar

12
Lib/test/test_copy_reg.py
View File

@ -40,7 +40,7 @@ class CopyRegTestCase(unittest.TestCase):
def test_bool(self):
import copy
self.assertEquals(True, copy.copy(True))
self.assertEqual(True, copy.copy(True))
def test_extension_registry(self):
mod, func, code = 'junk1 ', ' junk2', 0xabcd
@ -101,16 +101,16 @@ class CopyRegTestCase(unittest.TestCase):
mod, func, code)
def test_slotnames(self):
self.assertEquals(copy_reg._slotnames(WithoutSlots), [])
self.assertEquals(copy_reg._slotnames(WithWeakref), [])
self.assertEqual(copy_reg._slotnames(WithoutSlots), [])
self.assertEqual(copy_reg._slotnames(WithWeakref), [])
expected = ['_WithPrivate__spam']
self.assertEquals(copy_reg._slotnames(WithPrivate), expected)
self.assertEquals(copy_reg._slotnames(WithSingleString), ['spam'])
self.assertEqual(copy_reg._slotnames(WithPrivate), expected)
self.assertEqual(copy_reg._slotnames(WithSingleString), ['spam'])
expected = ['eggs', 'spam']
expected.sort()
result = copy_reg._slotnames(WithInherited)
result.sort()
self.assertEquals(result, expected)
self.assertEqual(result, expected)
def test_main():

6
Lib/test/test_datetime.py
View File

@ -1491,8 +1491,8 @@ class TestDateTime(TestDate):
def test_microsecond_rounding(self):
# Test whether fromtimestamp "rounds up" floats that are less
# than one microsecond smaller than an integer.
self.assertEquals(self.theclass.fromtimestamp(0.9999999),
self.theclass.fromtimestamp(1))
self.assertEqual(self.theclass.fromtimestamp(0.9999999),
self.theclass.fromtimestamp(1))
def test_insane_fromtimestamp(self):
# It's possible that some platform maps time_t to double,
@ -1520,7 +1520,7 @@ class TestDateTime(TestDate):
@unittest.skipIf(sys.platform == "win32", "Windows doesn't accept negative timestamps")
def test_negative_float_utcfromtimestamp(self):
d = self.theclass.utcfromtimestamp(-1.05)
self.assertEquals(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
self.assertEqual(d, self.theclass(1969, 12, 31, 23, 59, 58, 950000))
def test_utcnow(self):
import time

2
Lib/test/test_deque.py
View File

@ -234,7 +234,7 @@ class TestBasic(unittest.TestCase):
d = deque(data[:i])
r = d.reverse()
self.assertEqual(list(d), list(reversed(data[:i])))
self.assert_(r is None)
self.assertIs(r, None)
d.reverse()
self.assertEqual(list(d), data[:i])
self.assertRaises(TypeError, d.reverse, 1) # Arity is zero

8
Lib/test/test_descr.py
View File

@ -4534,11 +4534,11 @@ order (MRO) for bases """
__getattr__ = descr
self.assertRaises(AttributeError, getattr, A(), "attr")
self.assertEquals(descr.counter, 1)
self.assertEqual(descr.counter, 1)
self.assertRaises(AttributeError, getattr, B(), "attr")
self.assertEquals(descr.counter, 2)
self.assertEqual(descr.counter, 2)
self.assertRaises(AttributeError, getattr, C(), "attr")
self.assertEquals(descr.counter, 4)
self.assertEqual(descr.counter, 4)
import gc
class EvilGetattribute(object):
@ -4565,7 +4565,7 @@ class DictProxyTests(unittest.TestCase):
# Testing dict-proxy iterkeys...
keys = [ key for key in self.C.__dict__.iterkeys() ]
keys.sort()
self.assertEquals(keys, ['__dict__', '__doc__', '__module__',
self.assertEqual(keys, ['__dict__', '__doc__', '__module__',
'__weakref__', 'meth'])
def test_iter_values(self):

6
Lib/test/test_dircache.py
View File

@ -35,7 +35,7 @@ class DircacheTests(unittest.TestCase):
def test_listdir(self):
## SUCCESSFUL CASES
entries = dircache.listdir(self.tempdir)
self.assertEquals(entries, [])
self.assertEqual(entries, [])
# Check that cache is actually caching, not just passing through.
self.assertTrue(dircache.listdir(self.tempdir) is entries)
@ -52,7 +52,7 @@ class DircacheTests(unittest.TestCase):
time.sleep(1)
self.writeTemp("test1")
entries = dircache.listdir(self.tempdir)
self.assertEquals(entries, ['test1'])
self.assertEqual(entries, ['test1'])
self.assertTrue(dircache.listdir(self.tempdir) is entries)
## UNSUCCESSFUL CASES
@ -63,7 +63,7 @@ class DircacheTests(unittest.TestCase):
self.mkdirTemp("A")
lst = ['A', 'test2', 'test_nonexistent']
dircache.annotate(self.tempdir, lst)
self.assertEquals(lst, ['A/', 'test2', 'test_nonexistent'])
self.assertEqual(lst, ['A/', 'test2', 'test_nonexistent'])
def test_main():

8
Lib/test/test_epoll.py
View File

@ -56,7 +56,7 @@ class TestEPoll(unittest.TestCase):
try:
client.connect(('127.0.0.1', self.serverSocket.getsockname()[1]))
except socket.error, e:
self.assertEquals(e.args[0], errno.EINPROGRESS)
self.assertEqual(e.args[0], errno.EINPROGRESS)
else:
raise AssertionError("Connect should have raised EINPROGRESS")
server, addr = self.serverSocket.accept()
@ -162,7 +162,7 @@ class TestEPoll(unittest.TestCase):
(server.fileno(), select.EPOLLOUT)]
expected.sort()
self.assertEquals(events, expected)
self.assertEqual(events, expected)
self.assertFalse(then - now > 0.01, then - now)
now = time.time()
@ -183,7 +183,7 @@ class TestEPoll(unittest.TestCase):
(server.fileno(), select.EPOLLIN | select.EPOLLOUT)]
expected.sort()
self.assertEquals(events, expected)
self.assertEqual(events, expected)
ep.unregister(client.fileno())
ep.modify(server.fileno(), select.EPOLLOUT)
@ -193,7 +193,7 @@ class TestEPoll(unittest.TestCase):
self.assertFalse(then - now > 0.01)
expected = [(server.fileno(), select.EPOLLOUT)]
self.assertEquals(events, expected)
self.assertEqual(events, expected)
def test_errors(self):
self.assertRaises(ValueError, select.epoll, -2)

28
Lib/test/test_exceptions.py
View File

@ -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():

14
Lib/test/test_file.py
View File

@ -30,7 +30,7 @@ class AutoFileTests(unittest.TestCase):
# verify weak references
p = proxy(self.f)
p.write(b'teststring')
self.assertEquals(self.f.tell(), p.tell())
self.assertEqual(self.f.tell(), p.tell())
self.f.close()
self.f = None
self.assertRaises(ReferenceError, getattr, p, 'tell')
@ -49,7 +49,7 @@ class AutoFileTests(unittest.TestCase):
a = array('b', b'x'*10)
self.f = self.open(TESTFN, 'rb')
n = self.f.readinto(a)
self.assertEquals(b'12', a.tostring()[:n])
self.assertEqual(b'12', a.tostring()[:n])
def testReadinto_text(self):
# verify readinto refuses text files
@ -66,7 +66,7 @@ class AutoFileTests(unittest.TestCase):
self.f.close()
self.f = self.open(TESTFN, 'rb')
buf = self.f.read()
self.assertEquals(buf, b'12')
self.assertEqual(buf, b'12')
def testWritelinesIntegers(self):
# verify writelines with integers
@ -87,7 +87,7 @@ class AutoFileTests(unittest.TestCase):
def testErrors(self):
f = self.f
self.assertEquals(f.name, TESTFN)
self.assertEqual(f.name, TESTFN)
self.assertTrue(not f.isatty())
self.assertTrue(not f.closed)
@ -124,12 +124,12 @@ class AutoFileTests(unittest.TestCase):
self.assertRaises(ValueError, method, *args)
# file is closed, __exit__ shouldn't do anything
self.assertEquals(self.f.__exit__(None, None, None), None)
self.assertEqual(self.f.__exit__(None, None, None), None)
# it must also return None if an exception was given
try:
1 // 0
except:
self.assertEquals(self.f.__exit__(*sys.exc_info()), None)
self.assertEqual(self.f.__exit__(*sys.exc_info()), None)
def testReadWhenWriting(self):
self.assertRaises(IOError, self.f.read)
@ -195,7 +195,7 @@ class OtherFileTests(unittest.TestCase):
f.close()
except IOError as msg:
self.fail('error setting buffer size %d: %s' % (s, str(msg)))
self.assertEquals(d, s)
self.assertEqual(d, s)
def testTruncateOnWindows(self):
# SF bug <http://www.python.org/sf/801631>

16
Lib/test/test_file2k.py
View File

@ -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:

Some files were not shown because too many files have changed in this diff Show More