change deprecated unittest method calls into their proper names.

Lib/sqlite3/test/factory.py

@@ -47,7 +47,7 @@ class ConnectionFactoryTests(unittest.TestCase):
         self.con.close()
 
     def CheckIsInstance(self):
-        self.failUnless(isinstance(self.con,
+        self.assertTrue(isinstance(self.con,
                                    MyConnection),
                         "connection is not instance of MyConnection")
 
@@ -60,7 +60,7 @@ class CursorFactoryTests(unittest.TestCase):
 
     def CheckIsInstance(self):
         cur = self.con.cursor(factory=MyCursor)
-        self.failUnless(isinstance(cur,
+        self.assertTrue(isinstance(cur,
                                    MyCursor),
                         "cursor is not instance of MyCursor")
 
@@ -72,7 +72,7 @@ class RowFactoryTestsBackwardsCompat(unittest.TestCase):
         cur = self.con.cursor(factory=MyCursor)
         cur.execute("select 4+5 as foo")
         row = cur.fetchone()
-        self.failUnless(isinstance(row,
+        self.assertTrue(isinstance(row,
                                    dict),
                         "row is not instance of dict")
         cur.close()
@@ -87,28 +87,28 @@ class RowFactoryTests(unittest.TestCase):
     def CheckCustomFactory(self):
         self.con.row_factory = lambda cur, row: list(row)
         row = self.con.execute("select 1, 2").fetchone()
-        self.failUnless(isinstance(row,
+        self.assertTrue(isinstance(row,
                                    list),
                         "row is not instance of list")
 
     def CheckSqliteRowIndex(self):
         self.con.row_factory = sqlite.Row
         row = self.con.execute("select 1 as a, 2 as b").fetchone()
-        self.failUnless(isinstance(row,
+        self.assertTrue(isinstance(row,
                                    sqlite.Row),
                         "row is not instance of sqlite.Row")
 
         col1, col2 = row["a"], row["b"]
-        self.failUnless(col1 == 1, "by name: wrong result for column 'a'")
-        self.failUnless(col2 == 2, "by name: wrong result for column 'a'")
+        self.assertTrue(col1 == 1, "by name: wrong result for column 'a'")
+        self.assertTrue(col2 == 2, "by name: wrong result for column 'a'")
 
         col1, col2 = row["A"], row["B"]
-        self.failUnless(col1 == 1, "by name: wrong result for column 'A'")
-        self.failUnless(col2 == 2, "by name: wrong result for column 'B'")
+        self.assertTrue(col1 == 1, "by name: wrong result for column 'A'")
+        self.assertTrue(col2 == 2, "by name: wrong result for column 'B'")
 
         col1, col2 = row[0], row[1]
-        self.failUnless(col1 == 1, "by index: wrong result for column 0")
-        self.failUnless(col2 == 2, "by index: wrong result for column 1")
+        self.assertTrue(col1 == 1, "by index: wrong result for column 0")
+        self.assertTrue(col2 == 2, "by index: wrong result for column 1")
 
     def CheckSqliteRowIter(self):
         """Checks if the row object is iterable"""
@@ -128,8 +128,8 @@ class RowFactoryTests(unittest.TestCase):
         self.con.row_factory = sqlite.Row
         row = self.con.execute("select 1 as a, 2 as b").fetchone()
         d = dict(row)
-        self.failUnlessEqual(d["a"], row["a"])
-        self.failUnlessEqual(d["b"], row["b"])
+        self.assertEqual(d["a"], row["a"])
+        self.assertEqual(d["b"], row["b"])
 
     def CheckSqliteRowHashCmp(self):
         """Checks if the row object compares and hashes correctly"""
@@ -138,18 +138,18 @@ class RowFactoryTests(unittest.TestCase):
         row_2 = self.con.execute("select 1 as a, 2 as b").fetchone()
         row_3 = self.con.execute("select 1 as a, 3 as b").fetchone()
 
-        self.failUnless(row_1 == row_1)
-        self.failUnless(row_1 == row_2)
-        self.failUnless(row_2 != row_3)
+        self.assertTrue(row_1 == row_1)
+        self.assertTrue(row_1 == row_2)
+        self.assertTrue(row_2 != row_3)
 
-        self.failIf(row_1 != row_1)
-        self.failIf(row_1 != row_2)
-        self.failIf(row_2 == row_3)
+        self.assertFalse(row_1 != row_1)
+        self.assertFalse(row_1 != row_2)
+        self.assertFalse(row_2 == row_3)
 
-        self.failUnlessEqual(row_1, row_2)
-        self.failUnlessEqual(hash(row_1), hash(row_2))
-        self.failIfEqual(row_1, row_3)
-        self.failIfEqual(hash(row_1), hash(row_3))
+        self.assertEqual(row_1, row_2)
+        self.assertEqual(hash(row_1), hash(row_2))
+        self.assertNotEqual(row_1, row_3)
+        self.assertNotEqual(hash(row_1), hash(row_3))
 
     def tearDown(self):
         self.con.close()
@@ -161,21 +161,21 @@ class TextFactoryTests(unittest.TestCase):
     def CheckUnicode(self):
         austria = "sterreich"
         row = self.con.execute("select ?", (austria,)).fetchone()
-        self.failUnless(type(row[0]) == str, "type of row[0] must be unicode")
+        self.assertTrue(type(row[0]) == str, "type of row[0] must be unicode")
 
     def CheckString(self):
         self.con.text_factory = bytes
         austria = "sterreich"
         row = self.con.execute("select ?", (austria,)).fetchone()
-        self.failUnless(type(row[0]) == bytes, "type of row[0] must be bytes")
-        self.failUnless(row[0] == austria.encode("utf-8"), "column must equal original data in UTF-8")
+        self.assertTrue(type(row[0]) == bytes, "type of row[0] must be bytes")
+        self.assertTrue(row[0] == austria.encode("utf-8"), "column must equal original data in UTF-8")
 
     def CheckCustom(self):
         self.con.text_factory = lambda x: str(x, "utf-8", "ignore")
         austria = "sterreich"
         row = self.con.execute("select ?", (austria,)).fetchone()
-        self.failUnless(type(row[0]) == str, "type of row[0] must be unicode")
-        self.failUnless(row[0].endswith("reich"), "column must contain original data")
+        self.assertTrue(type(row[0]) == str, "type of row[0] must be unicode")
+        self.assertTrue(row[0].endswith("reich"), "column must contain original data")
 
     def CheckOptimizedUnicode(self):
         self.con.text_factory = sqlite.OptimizedUnicode
@@ -183,8 +183,8 @@ class TextFactoryTests(unittest.TestCase):
         germany = "Deutchland"
         a_row = self.con.execute("select ?", (austria,)).fetchone()
         d_row = self.con.execute("select ?", (germany,)).fetchone()
-        self.failUnless(type(a_row[0]) == str, "type of non-ASCII row must be str")
-        self.failUnless(type(d_row[0]) == str, "type of ASCII-only row must be str")
+        self.assertTrue(type(a_row[0]) == str, "type of non-ASCII row must be str")
+        self.assertTrue(type(d_row[0]) == str, "type of ASCII-only row must be str")
 
     def tearDown(self):
         self.con.close()

Lib/sqlite3/test/hooks.py

@@ -37,7 +37,7 @@ class CollationTests(unittest.TestCase):
             con.create_collation("X", 42)
             self.fail("should have raised a TypeError")
         except TypeError as e:
-            self.failUnlessEqual(e.args[0], "parameter must be callable")
+            self.assertEqual(e.args[0], "parameter must be callable")
 
     def CheckCreateCollationNotAscii(self):
         con = sqlite.connect(":memory:")
@@ -74,7 +74,7 @@ class CollationTests(unittest.TestCase):
             result = con.execute(sql).fetchall()
             self.fail("should have raised an OperationalError")
         except sqlite.OperationalError as e:
-            self.failUnlessEqual(e.args[0].lower(), "no such collation sequence: mycoll")
+            self.assertEqual(e.args[0].lower(), "no such collation sequence: mycoll")
 
     def CheckCollationRegisterTwice(self):
         """
@@ -119,7 +119,7 @@ class ProgressTests(unittest.TestCase):
         con.execute("""
             create table foo(a, b)
             """)
-        self.failUnless(progress_calls)
+        self.assertTrue(progress_calls)
 
 
     def CheckOpcodeCount(self):
@@ -143,7 +143,7 @@ class ProgressTests(unittest.TestCase):
             create table bar (a, b)
             """)
         second_count = len(progress_calls)
-        self.failUnless(first_count > second_count)
+        self.assertTrue(first_count > second_count)
 
     def CheckCancelOperation(self):
         """
@@ -173,7 +173,7 @@ class ProgressTests(unittest.TestCase):
         con.set_progress_handler(progress, 1)
         con.set_progress_handler(None, 1)
         con.execute("select 1 union select 2 union select 3").fetchall()
-        self.failUnlessEqual(action, 0, "progress handler was not cleared")
+        self.assertEqual(action, 0, "progress handler was not cleared")
 
 def suite():
     collation_suite = unittest.makeSuite(CollationTests, "Check")

Lib/sqlite3/test/regression.py

@@ -65,10 +65,10 @@ class RegressionTests(unittest.TestCase):
     def CheckColumnNameWithSpaces(self):
         cur = self.con.cursor()
         cur.execute('select 1 as "foo bar [datetime]"')
-        self.failUnlessEqual(cur.description[0][0], "foo bar")
+        self.assertEqual(cur.description[0][0], "foo bar")
 
         cur.execute('select 1 as "foo baz"')
-        self.failUnlessEqual(cur.description[0][0], "foo baz")
+        self.assertEqual(cur.description[0][0], "foo baz")
 
     def CheckStatementAvailable(self):
         # pysqlite up to 2.3.2 crashed on this, because the active statement handle was not checked

Lib/sqlite3/test/transactions.py

@@ -58,14 +58,14 @@ class TransactionTests(unittest.TestCase):
         self.cur1.execute("create table test2(j)")
         self.cur2.execute("select i from test")
         res = self.cur2.fetchall()
-        self.failUnlessEqual(len(res), 1)
+        self.assertEqual(len(res), 1)
 
     def CheckInsertStartsTransaction(self):
         self.cur1.execute("create table test(i)")
         self.cur1.execute("insert into test(i) values (5)")
         self.cur2.execute("select i from test")
         res = self.cur2.fetchall()
-        self.failUnlessEqual(len(res), 0)
+        self.assertEqual(len(res), 0)
 
     def CheckUpdateStartsTransaction(self):
         self.cur1.execute("create table test(i)")
@@ -74,7 +74,7 @@ class TransactionTests(unittest.TestCase):
         self.cur1.execute("update test set i=6")
         self.cur2.execute("select i from test")
         res = self.cur2.fetchone()[0]
-        self.failUnlessEqual(res, 5)
+        self.assertEqual(res, 5)
 
     def CheckDeleteStartsTransaction(self):
         self.cur1.execute("create table test(i)")
@@ -83,7 +83,7 @@ class TransactionTests(unittest.TestCase):
         self.cur1.execute("delete from test")
         self.cur2.execute("select i from test")
         res = self.cur2.fetchall()
-        self.failUnlessEqual(len(res), 1)
+        self.assertEqual(len(res), 1)
 
     def CheckReplaceStartsTransaction(self):
         self.cur1.execute("create table test(i)")
@@ -92,24 +92,24 @@ class TransactionTests(unittest.TestCase):
         self.cur1.execute("replace into test(i) values (6)")
         self.cur2.execute("select i from test")
         res = self.cur2.fetchall()
-        self.failUnlessEqual(len(res), 1)
-        self.failUnlessEqual(res[0][0], 5)
+        self.assertEqual(len(res), 1)
+        self.assertEqual(res[0][0], 5)
 
     def CheckToggleAutoCommit(self):
         self.cur1.execute("create table test(i)")
         self.cur1.execute("insert into test(i) values (5)")
         self.con1.isolation_level = None
-        self.failUnlessEqual(self.con1.isolation_level, None)
+        self.assertEqual(self.con1.isolation_level, None)
         self.cur2.execute("select i from test")
         res = self.cur2.fetchall()
-        self.failUnlessEqual(len(res), 1)
+        self.assertEqual(len(res), 1)
 
         self.con1.isolation_level = "DEFERRED"
-        self.failUnlessEqual(self.con1.isolation_level , "DEFERRED")
+        self.assertEqual(self.con1.isolation_level , "DEFERRED")
         self.cur1.execute("insert into test(i) values (5)")
         self.cur2.execute("select i from test")
         res = self.cur2.fetchall()
-        self.failUnlessEqual(len(res), 1)
+        self.assertEqual(len(res), 1)
 
     def CheckRaiseTimeout(self):
         if sqlite.sqlite_version_info < (3, 2, 2):

Lib/sqlite3/test/types.py

@@ -39,27 +39,27 @@ class SqliteTypeTests(unittest.TestCase):
         self.cur.execute("insert into test(s) values (?)", ("sterreich",))
         self.cur.execute("select s from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], "sterreich")
+        self.assertEqual(row[0], "sterreich")
 
     def CheckSmallInt(self):
         self.cur.execute("insert into test(i) values (?)", (42,))
         self.cur.execute("select i from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], 42)
+        self.assertEqual(row[0], 42)
 
     def CheckLargeInt(self):
         num = 2**40
         self.cur.execute("insert into test(i) values (?)", (num,))
         self.cur.execute("select i from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], num)
+        self.assertEqual(row[0], num)
 
     def CheckFloat(self):
         val = 3.14
         self.cur.execute("insert into test(f) values (?)", (val,))
         self.cur.execute("select f from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], val)
+        self.assertEqual(row[0], val)
 
     def CheckBlob(self):
         sample = b"Guglhupf"
@@ -67,12 +67,12 @@ class SqliteTypeTests(unittest.TestCase):
         self.cur.execute("insert into test(b) values (?)", (val,))
         self.cur.execute("select b from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], sample)
+        self.assertEqual(row[0], sample)
 
     def CheckUnicodeExecute(self):
         self.cur.execute("select 'sterreich'")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], "sterreich")
+        self.assertEqual(row[0], "sterreich")
 
 class DeclTypesTests(unittest.TestCase):
     class Foo:
@@ -133,14 +133,14 @@ class DeclTypesTests(unittest.TestCase):
         self.cur.execute("insert into test(s) values (?)", ("foo",))
         self.cur.execute('select s as "s [WRONG]" from test')
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], "foo")
+        self.assertEqual(row[0], "foo")
 
     def CheckSmallInt(self):
         # default
         self.cur.execute("insert into test(i) values (?)", (42,))
         self.cur.execute("select i from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], 42)
+        self.assertEqual(row[0], 42)
 
     def CheckLargeInt(self):
         # default
@@ -148,7 +148,7 @@ class DeclTypesTests(unittest.TestCase):
         self.cur.execute("insert into test(i) values (?)", (num,))
         self.cur.execute("select i from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], num)
+        self.assertEqual(row[0], num)
 
     def CheckFloat(self):
         # custom
@@ -156,20 +156,20 @@ class DeclTypesTests(unittest.TestCase):
         self.cur.execute("insert into test(f) values (?)", (val,))
         self.cur.execute("select f from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], 47.2)
+        self.assertEqual(row[0], 47.2)
 
     def CheckBool(self):
         # custom
         self.cur.execute("insert into test(b) values (?)", (False,))
         self.cur.execute("select b from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], False)
+        self.assertEqual(row[0], False)
 
         self.cur.execute("delete from test")
         self.cur.execute("insert into test(b) values (?)", (True,))
         self.cur.execute("select b from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], True)
+        self.assertEqual(row[0], True)
 
     def CheckUnicode(self):
         # default
@@ -177,14 +177,14 @@ class DeclTypesTests(unittest.TestCase):
         self.cur.execute("insert into test(u) values (?)", (val,))
         self.cur.execute("select u from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], val)
+        self.assertEqual(row[0], val)
 
     def CheckFoo(self):
         val = DeclTypesTests.Foo("bla")
         self.cur.execute("insert into test(foo) values (?)", (val,))
         self.cur.execute("select foo from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], val)
+        self.assertEqual(row[0], val)
 
     def CheckUnsupportedSeq(self):
         class Bar: pass
@@ -215,20 +215,20 @@ class DeclTypesTests(unittest.TestCase):
         self.cur.execute("insert into test(bin) values (?)", (val,))
         self.cur.execute("select bin from test")
         row = self.cur.fetchone()
-        self.failUnlessEqual(row[0], sample)
+        self.assertEqual(row[0], sample)
 
     def CheckNumber1(self):
         self.cur.execute("insert into test(n1) values (5)")
         value = self.cur.execute("select n1 from test").fetchone()[0]
         # if the converter is not used, it's an int instead of a float
-        self.failUnlessEqual(type(value), float)
+        self.assertEqual(type(value), float)
 
     def CheckNumber2(self):
         """Checks wether converter names are cut off at '(' characters"""
         self.cur.execute("insert into test(n2) values (5)")
         value = self.cur.execute("select n2 from test").fetchone()[0]
         # if the converter is not used, it's an int instead of a float
-        self.failUnlessEqual(type(value), float)
+        self.assertEqual(type(value), float)
 
 class ColNamesTests(unittest.TestCase):
     def setUp(self):
@@ -257,28 +257,28 @@ class ColNamesTests(unittest.TestCase):
         self.cur.execute("insert into test(x) values (?)", ("xxx",))
         self.cur.execute("select x from test")
         val = self.cur.fetchone()[0]
-        self.failUnlessEqual(val, "xxx")
+        self.assertEqual(val, "xxx")
 
     def CheckNone(self):
         self.cur.execute("insert into test(x) values (?)", (None,))
         self.cur.execute("select x from test")
         val = self.cur.fetchone()[0]
-        self.failUnlessEqual(val, None)
+        self.assertEqual(val, None)
 
     def CheckColName(self):
         self.cur.execute("insert into test(x) values (?)", ("xxx",))
         self.cur.execute('select x as "x [bar]" from test')
         val = self.cur.fetchone()[0]
-        self.failUnlessEqual(val, "<xxx>")
+        self.assertEqual(val, "<xxx>")
 
         # Check if the stripping of colnames works. Everything after the first
         # whitespace should be stripped.
-        self.failUnlessEqual(self.cur.description[0][0], "x")
+        self.assertEqual(self.cur.description[0][0], "x")
 
     def CheckCaseInConverterName(self):
         self.cur.execute("select 'other' as \"x [b1b1]\"")
         val = self.cur.fetchone()[0]
-        self.failUnlessEqual(val, "MARKER")
+        self.assertEqual(val, "MARKER")
 
     def CheckCursorDescriptionNoRow(self):
         """
@@ -310,7 +310,7 @@ class ObjectAdaptationTests(unittest.TestCase):
     def CheckCasterIsUsed(self):
         self.cur.execute("select ?", (4,))
         val = self.cur.fetchone()[0]
-        self.failUnlessEqual(type(val), float)
+        self.assertEqual(type(val), float)
 
 class BinaryConverterTests(unittest.TestCase):
     def convert(s):
@@ -327,7 +327,7 @@ class BinaryConverterTests(unittest.TestCase):
     def CheckBinaryInputForConverter(self):
         testdata = b"abcdefg" * 10
         result = self.con.execute('select ? as "x [bin]"', (memoryview(zlib.compress(testdata)),)).fetchone()[0]
-        self.failUnlessEqual(testdata, result)
+        self.assertEqual(testdata, result)
 
 class DateTimeTests(unittest.TestCase):
     def setUp(self):
@@ -344,14 +344,14 @@ class DateTimeTests(unittest.TestCase):
         self.cur.execute("insert into test(d) values (?)", (d,))
         self.cur.execute("select d from test")
         d2 = self.cur.fetchone()[0]
-        self.failUnlessEqual(d, d2)
+        self.assertEqual(d, d2)
 
     def CheckSqliteTimestamp(self):
         ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0)
         self.cur.execute("insert into test(ts) values (?)", (ts,))
         self.cur.execute("select ts from test")
         ts2 = self.cur.fetchone()[0]
-        self.failUnlessEqual(ts, ts2)
+        self.assertEqual(ts, ts2)
 
     def CheckSqlTimestamp(self):
         # The date functions are only available in SQLite version 3.1 or later
@@ -363,22 +363,22 @@ class DateTimeTests(unittest.TestCase):
         self.cur.execute("insert into test(ts) values (current_timestamp)")
         self.cur.execute("select ts from test")
         ts = self.cur.fetchone()[0]
-        self.failUnlessEqual(type(ts), datetime.datetime)
-        self.failUnlessEqual(ts.year, now.year)
+        self.assertEqual(type(ts), datetime.datetime)
+        self.assertEqual(ts.year, now.year)
 
     def CheckDateTimeSubSeconds(self):
         ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0, 500000)
         self.cur.execute("insert into test(ts) values (?)", (ts,))
         self.cur.execute("select ts from test")
         ts2 = self.cur.fetchone()[0]
-        self.failUnlessEqual(ts, ts2)
+        self.assertEqual(ts, ts2)
 
     def CheckDateTimeSubSecondsFloatingPoint(self):
         ts = sqlite.Timestamp(2004, 2, 14, 7, 15, 0, 510241)
         self.cur.execute("insert into test(ts) values (?)", (ts,))
         self.cur.execute("select ts from test")
         ts2 = self.cur.fetchone()[0]
-        self.failUnlessEqual(ts, ts2)
+        self.assertEqual(ts, ts2)
 
 def suite():
     sqlite_type_suite = unittest.makeSuite(SqliteTypeTests, "Check")

Lib/sqlite3/test/userfunctions.py

@@ -161,28 +161,28 @@ class FunctionTests(unittest.TestCase):
         cur = self.con.cursor()
         cur.execute("select returntext()")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(type(val), str)
-        self.failUnlessEqual(val, "foo")
+        self.assertEqual(type(val), str)
+        self.assertEqual(val, "foo")
 
     def CheckFuncReturnUnicode(self):
         cur = self.con.cursor()
         cur.execute("select returnunicode()")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(type(val), str)
-        self.failUnlessEqual(val, "bar")
+        self.assertEqual(type(val), str)
+        self.assertEqual(val, "bar")
 
     def CheckFuncReturnInt(self):
         cur = self.con.cursor()
         cur.execute("select returnint()")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(type(val), int)
-        self.failUnlessEqual(val, 42)
+        self.assertEqual(type(val), int)
+        self.assertEqual(val, 42)
 
     def CheckFuncReturnFloat(self):
         cur = self.con.cursor()
         cur.execute("select returnfloat()")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(type(val), float)
+        self.assertEqual(type(val), float)
         if val < 3.139 or val > 3.141:
             self.fail("wrong value")
 
@@ -190,15 +190,15 @@ class FunctionTests(unittest.TestCase):
         cur = self.con.cursor()
         cur.execute("select returnnull()")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(type(val), type(None))
-        self.failUnlessEqual(val, None)
+        self.assertEqual(type(val), type(None))
+        self.assertEqual(val, None)
 
     def CheckFuncReturnBlob(self):
         cur = self.con.cursor()
         cur.execute("select returnblob()")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(type(val), bytes)
-        self.failUnlessEqual(val, b"blob")
+        self.assertEqual(type(val), bytes)
+        self.assertEqual(val, b"blob")
 
     def CheckFuncException(self):
         cur = self.con.cursor()
@@ -207,37 +207,37 @@ class FunctionTests(unittest.TestCase):
             cur.fetchone()
             self.fail("should have raised OperationalError")
         except sqlite.OperationalError as e:
-            self.failUnlessEqual(e.args[0], 'user-defined function raised exception')
+            self.assertEqual(e.args[0], 'user-defined function raised exception')
 
     def CheckParamString(self):
         cur = self.con.cursor()
         cur.execute("select isstring(?)", ("foo",))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckParamInt(self):
         cur = self.con.cursor()
         cur.execute("select isint(?)", (42,))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckParamFloat(self):
         cur = self.con.cursor()
         cur.execute("select isfloat(?)", (3.14,))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckParamNone(self):
         cur = self.con.cursor()
         cur.execute("select isnone(?)", (None,))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckParamBlob(self):
         cur = self.con.cursor()
         cur.execute("select isblob(?)", (memoryview(b"blob"),))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
 class AggregateTests(unittest.TestCase):
     def setUp(self):
@@ -281,7 +281,7 @@ class AggregateTests(unittest.TestCase):
             cur.execute("select nostep(t) from test")
             self.fail("should have raised an AttributeError")
         except AttributeError as e:
-            self.failUnlessEqual(e.args[0], "'AggrNoStep' object has no attribute 'step'")
+            self.assertEqual(e.args[0], "'AggrNoStep' object has no attribute 'step'")
 
     def CheckAggrNoFinalize(self):
         cur = self.con.cursor()
@@ -290,7 +290,7 @@ class AggregateTests(unittest.TestCase):
             val = cur.fetchone()[0]
             self.fail("should have raised an OperationalError")
         except sqlite.OperationalError as e:
-            self.failUnlessEqual(e.args[0], "user-defined aggregate's 'finalize' method raised error")
+            self.assertEqual(e.args[0], "user-defined aggregate's 'finalize' method raised error")
 
     def CheckAggrExceptionInInit(self):
         cur = self.con.cursor()
@@ -299,7 +299,7 @@ class AggregateTests(unittest.TestCase):
             val = cur.fetchone()[0]
             self.fail("should have raised an OperationalError")
         except sqlite.OperationalError as e:
-            self.failUnlessEqual(e.args[0], "user-defined aggregate's '__init__' method raised error")
+            self.assertEqual(e.args[0], "user-defined aggregate's '__init__' method raised error")
 
     def CheckAggrExceptionInStep(self):
         cur = self.con.cursor()
@@ -308,7 +308,7 @@ class AggregateTests(unittest.TestCase):
             val = cur.fetchone()[0]
             self.fail("should have raised an OperationalError")
         except sqlite.OperationalError as e:
-            self.failUnlessEqual(e.args[0], "user-defined aggregate's 'step' method raised error")
+            self.assertEqual(e.args[0], "user-defined aggregate's 'step' method raised error")
 
     def CheckAggrExceptionInFinalize(self):
         cur = self.con.cursor()
@@ -317,37 +317,37 @@ class AggregateTests(unittest.TestCase):
             val = cur.fetchone()[0]
             self.fail("should have raised an OperationalError")
         except sqlite.OperationalError as e:
-            self.failUnlessEqual(e.args[0], "user-defined aggregate's 'finalize' method raised error")
+            self.assertEqual(e.args[0], "user-defined aggregate's 'finalize' method raised error")
 
     def CheckAggrCheckParamStr(self):
         cur = self.con.cursor()
         cur.execute("select checkType('str', ?)", ("foo",))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckAggrCheckParamInt(self):
         cur = self.con.cursor()
         cur.execute("select checkType('int', ?)", (42,))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckAggrCheckParamFloat(self):
         cur = self.con.cursor()
         cur.execute("select checkType('float', ?)", (3.14,))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckAggrCheckParamNone(self):
         cur = self.con.cursor()
         cur.execute("select checkType('None', ?)", (None,))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckAggrCheckParamBlob(self):
         cur = self.con.cursor()
         cur.execute("select checkType('blob', ?)", (memoryview(b"blob"),))
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 1)
+        self.assertEqual(val, 1)
 
     def CheckAggrCheckAggrSum(self):
         cur = self.con.cursor()
@@ -355,7 +355,7 @@ class AggregateTests(unittest.TestCase):
         cur.executemany("insert into test(i) values (?)", [(10,), (20,), (30,)])
         cur.execute("select mysum(i) from test")
         val = cur.fetchone()[0]
-        self.failUnlessEqual(val, 60)
+        self.assertEqual(val, 60)
 
 def authorizer_cb(action, arg1, arg2, dbname, source):
     if action != sqlite.SQLITE_SELECT: