mirrors/cpython
1
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-08-30 13:38:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 8

change deprecated unittest method calls into their proper names.

Browse source
This commit is contained in:
Gregory P. Smith 2009-07-04 08:32:15 +00:00
parent 0d3fa833a1
commit 04cecafce1
7 changed files with 151 additions and 151 deletions
Download patch file Download diff file Expand all files Collapse all files

92
Lib/sqlite3/test/dbapi.py
View file

@ -44,39 +44,39 @@ class ModuleTests(unittest.TestCase):
"Warning is not a subclass of Exception")
def CheckError(self):
self.failUnless(issubclass(sqlite.Error, Exception),
self.assertTrue(issubclass(sqlite.Error, Exception),
"Error is not a subclass of Exception")
def CheckInterfaceError(self):
self.failUnless(issubclass(sqlite.InterfaceError, sqlite.Error),
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
"InterfaceError is not a subclass of Error")
def CheckDatabaseError(self):
self.failUnless(issubclass(sqlite.DatabaseError, sqlite.Error),
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
"DatabaseError is not a subclass of Error")
def CheckDataError(self):
self.failUnless(issubclass(sqlite.DataError, sqlite.DatabaseError),
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
"DataError is not a subclass of DatabaseError")
def CheckOperationalError(self):
self.failUnless(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
"OperationalError is not a subclass of DatabaseError")
def CheckIntegrityError(self):
self.failUnless(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
"IntegrityError is not a subclass of DatabaseError")
def CheckInternalError(self):
self.failUnless(issubclass(sqlite.InternalError, sqlite.DatabaseError),
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
"InternalError is not a subclass of DatabaseError")
def CheckProgrammingError(self):
self.failUnless(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
"ProgrammingError is not a subclass of DatabaseError")
def CheckNotSupportedError(self):
self.failUnless(issubclass(sqlite.NotSupportedError,
self.assertTrue(issubclass(sqlite.NotSupportedError,
sqlite.DatabaseError),
"NotSupportedError is not a subclass of DatabaseError")
@ -126,16 +126,16 @@ class ConnectionTests(unittest.TestCase):
def CheckExceptions(self):
# Optional DB-API extension.
self.failUnlessEqual(self.cx.Warning, sqlite.Warning)
self.failUnlessEqual(self.cx.Error, sqlite.Error)
self.failUnlessEqual(self.cx.InterfaceError, sqlite.InterfaceError)
self.failUnlessEqual(self.cx.DatabaseError, sqlite.DatabaseError)
self.failUnlessEqual(self.cx.DataError, sqlite.DataError)
self.failUnlessEqual(self.cx.OperationalError, sqlite.OperationalError)
self.failUnlessEqual(self.cx.IntegrityError, sqlite.IntegrityError)
self.failUnlessEqual(self.cx.InternalError, sqlite.InternalError)
self.failUnlessEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.failUnlessEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
self.assertEqual(self.cx.Warning, sqlite.Warning)
self.assertEqual(self.cx.Error, sqlite.Error)
self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError)
self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError)
self.assertEqual(self.cx.DataError, sqlite.DataError)
self.assertEqual(self.cx.OperationalError, sqlite.OperationalError)
self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError)
self.assertEqual(self.cx.InternalError, sqlite.InternalError)
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
class CursorTests(unittest.TestCase):
def setUp(self):
@ -227,7 +227,7 @@ class CursorTests(unittest.TestCase):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", ["foo"])
row = self.cu.fetchone()
self.failUnlessEqual(row[0], "foo")
self.assertEqual(row[0], "foo")
def CheckExecuteParamSequence(self):
class L(object):
@ -240,13 +240,13 @@ class CursorTests(unittest.TestCase):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=?", L())
row = self.cu.fetchone()
self.failUnlessEqual(row[0], "foo")
self.assertEqual(row[0], "foo")
def CheckExecuteDictMapping(self):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", {"name": "foo"})
row = self.cu.fetchone()
self.failUnlessEqual(row[0], "foo")
self.assertEqual(row[0], "foo")
def CheckExecuteDictMapping_Mapping(self):
class D(dict):
@ -256,7 +256,7 @@ class CursorTests(unittest.TestCase):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("select name from test where name=:name", D())
row = self.cu.fetchone()
self.failUnlessEqual(row[0], "foo")
self.assertEqual(row[0], "foo")
def CheckExecuteDictMappingTooLittleArgs(self):
self.cu.execute("insert into test(name) values ('foo')")
@ -290,7 +290,7 @@ class CursorTests(unittest.TestCase):
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("insert into test(name) values ('foo')")
self.cu.execute("update test set name='bar'")
self.failUnlessEqual(self.cu.rowcount, 2)
self.assertEqual(self.cu.rowcount, 2)
def CheckRowcountSelect(self):
"""
@ -299,12 +299,12 @@ class CursorTests(unittest.TestCase):
has thus to be -1.
"""
self.cu.execute("select 5 union select 6")
self.failUnlessEqual(self.cu.rowcount, -1)
self.assertEqual(self.cu.rowcount, -1)
def CheckRowcountExecutemany(self):
self.cu.execute("delete from test")
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
self.failUnlessEqual(self.cu.rowcount, 3)
self.assertEqual(self.cu.rowcount, 3)
def CheckTotalChanges(self):
self.cu.execute("insert into test(name) values ('foo')")
@ -377,24 +377,24 @@ class CursorTests(unittest.TestCase):
lst = []
for row in self.cu:
lst.append(row[0])
self.failUnlessEqual(lst[0], 5)
self.failUnlessEqual(lst[1], 6)
self.assertEqual(lst[0], 5)
self.assertEqual(lst[1], 6)
def CheckFetchone(self):
self.cu.execute("select name from test")
row = self.cu.fetchone()
self.failUnlessEqual(row[0], "foo")
self.assertEqual(row[0], "foo")
row = self.cu.fetchone()
self.failUnlessEqual(row, None)
self.assertEqual(row, None)
def CheckFetchoneNoStatement(self):
cur = self.cx.cursor()
row = cur.fetchone()
self.failUnlessEqual(row, None)
self.assertEqual(row, None)
def CheckArraySize(self):
# must default ot 1
self.failUnlessEqual(self.cu.arraysize, 1)
self.assertEqual(self.cu.arraysize, 1)
# now set to 2
self.cu.arraysize = 2
@ -407,27 +407,27 @@ class CursorTests(unittest.TestCase):
self.cu.execute("select name from test")
res = self.cu.fetchmany()
self.failUnlessEqual(len(res), 2)
self.assertEqual(len(res), 2)
def CheckFetchmany(self):
self.cu.execute("select name from test")
res = self.cu.fetchmany(100)
self.failUnlessEqual(len(res), 1)
self.assertEqual(len(res), 1)
res = self.cu.fetchmany(100)
self.failUnlessEqual(res, [])
self.assertEqual(res, [])
def CheckFetchmanyKwArg(self):
"""Checks if fetchmany works with keyword arguments"""
self.cu.execute("select name from test")
res = self.cu.fetchmany(size=100)
self.failUnlessEqual(len(res), 1)
self.assertEqual(len(res), 1)
def CheckFetchall(self):
self.cu.execute("select name from test")
res = self.cu.fetchall()
self.failUnlessEqual(len(res), 1)
self.assertEqual(len(res), 1)
res = self.cu.fetchall()
self.failUnlessEqual(res, [])
self.assertEqual(res, [])
def CheckSetinputsizes(self):
self.cu.setinputsizes([3, 4, 5])
@ -440,7 +440,7 @@ class CursorTests(unittest.TestCase):
def CheckCursorConnection(self):
# Optional DB-API extension.
self.failUnlessEqual(self.cu.connection, self.cx)
self.assertEqual(self.cu.connection, self.cx)
def CheckWrongCursorCallable(self):
try:
@ -651,7 +651,7 @@ class ExtensionTests(unittest.TestCase):
""")
cur.execute("select i from a")
res = cur.fetchone()[0]
self.failUnlessEqual(res, 5)
self.assertEqual(res, 5)
def CheckScriptErrorIncomplete(self):
con = sqlite.connect(":memory:")
@ -661,7 +661,7 @@ class ExtensionTests(unittest.TestCase):
cur.executescript("create table test(sadfsadfdsa")
except sqlite.ProgrammingError:
raised = True
self.failUnlessEqual(raised, True, "should have raised an exception")
self.assertEqual(raised, True, "should have raised an exception")
def CheckScriptErrorNormal(self):
con = sqlite.connect(":memory:")
@ -671,26 +671,26 @@ class ExtensionTests(unittest.TestCase):
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
except sqlite.OperationalError:
raised = True
self.failUnlessEqual(raised, True, "should have raised an exception")
self.assertEqual(raised, True, "should have raised an exception")
def CheckConnectionExecute(self):
con = sqlite.connect(":memory:")
result = con.execute("select 5").fetchone()[0]
self.failUnlessEqual(result, 5, "Basic test of Connection.execute")
self.assertEqual(result, 5, "Basic test of Connection.execute")
def CheckConnectionExecutemany(self):
con = sqlite.connect(":memory:")
con.execute("create table test(foo)")
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
result = con.execute("select foo from test order by foo").fetchall()
self.failUnlessEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.failUnlessEqual(result[1][0], 4, "Basic test of Connection.executemany")
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
def CheckConnectionExecutescript(self):
con = sqlite.connect(":memory:")
con.executescript("create table test(foo); insert into test(foo) values (5);")
result = con.execute("select foo from test").fetchone()[0]
self.failUnlessEqual(result, 5, "Basic test of Connection.executescript")
self.assertEqual(result, 5, "Basic test of Connection.executescript")
class ClosedTests(unittest.TestCase):
def setUp(self):