mirror of https://github.com/python/cpython
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:
parent
40a92f5c65
commit
2623a37852
|
@ -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')
|
||||
|
|
|
@ -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,))
|
||||
|
|
|
@ -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.
|
||||
|
|
|
@ -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()
|
||||
|
||||
|
|
|
@ -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')
|
||||
|
||||
#----------------------------------------------------------------------
|
||||
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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))) :
|
||||
|
|
|
@ -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) :
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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']
|
||||
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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):
|
||||
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -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()
|
||||
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -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)))
|
||||
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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'),
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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")
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -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}'
|
||||
|
|
|
@ -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)))
|
||||
|
|
|
@ -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}')
|
||||
|
|
|
@ -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))
|
||||
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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))
|
||||
|
|
|
@ -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))
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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))
|
||||
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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),
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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()
|
||||
|
||||
|
|
|
@ -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"
|
||||
|
|
|
@ -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])
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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,
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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')
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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',
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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))
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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.
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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")
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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):
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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)
|
||||
|
|
|
@ -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():
|
||||
|
|
|
@ -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>
|
||||
|
|
|
@ -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
Loading…
Reference in New Issue