Thanks to visit codestin.com
Credit goes to github.com

Skip to content

Commit 04cecaf

Browse files
gpsheadgpshead
committed
change deprecated unittest method calls into their proper names.
1 parent 0d3fa83 commit 04cecaf

7 files changed

Lines changed: 151 additions & 151 deletions

File tree

‎Lib/sqlite3/test/dbapi.py‎

Lines changed: 46 additions & 46 deletions
Original file line numberDiff line numberDiff line change
@@ -44,39 +44,39 @@ def CheckWarning(self):
4444
"Warning is not a subclass of Exception")
4545

4646
def CheckError(self):
47-
self.failUnless(issubclass(sqlite.Error, Exception),
47+
self.assertTrue(issubclass(sqlite.Error, Exception),
4848
"Error is not a subclass of Exception")
4949

5050
def CheckInterfaceError(self):
51-
self.failUnless(issubclass(sqlite.InterfaceError, sqlite.Error),
51+
self.assertTrue(issubclass(sqlite.InterfaceError, sqlite.Error),
5252
"InterfaceError is not a subclass of Error")
5353

5454
def CheckDatabaseError(self):
55-
self.failUnless(issubclass(sqlite.DatabaseError, sqlite.Error),
55+
self.assertTrue(issubclass(sqlite.DatabaseError, sqlite.Error),
5656
"DatabaseError is not a subclass of Error")
5757

5858
def CheckDataError(self):
59-
self.failUnless(issubclass(sqlite.DataError, sqlite.DatabaseError),
59+
self.assertTrue(issubclass(sqlite.DataError, sqlite.DatabaseError),
6060
"DataError is not a subclass of DatabaseError")
6161

6262
def CheckOperationalError(self):
63-
self.failUnless(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
63+
self.assertTrue(issubclass(sqlite.OperationalError, sqlite.DatabaseError),
6464
"OperationalError is not a subclass of DatabaseError")
6565

6666
def CheckIntegrityError(self):
67-
self.failUnless(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
67+
self.assertTrue(issubclass(sqlite.IntegrityError, sqlite.DatabaseError),
6868
"IntegrityError is not a subclass of DatabaseError")
6969

7070
def CheckInternalError(self):
71-
self.failUnless(issubclass(sqlite.InternalError, sqlite.DatabaseError),
71+
self.assertTrue(issubclass(sqlite.InternalError, sqlite.DatabaseError),
7272
"InternalError is not a subclass of DatabaseError")
7373

7474
def CheckProgrammingError(self):
75-
self.failUnless(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
75+
self.assertTrue(issubclass(sqlite.ProgrammingError, sqlite.DatabaseError),
7676
"ProgrammingError is not a subclass of DatabaseError")
7777

7878
def CheckNotSupportedError(self):
79-
self.failUnless(issubclass(sqlite.NotSupportedError,
79+
self.assertTrue(issubclass(sqlite.NotSupportedError,
8080
sqlite.DatabaseError),
8181
"NotSupportedError is not a subclass of DatabaseError")
8282

@@ -126,16 +126,16 @@ def CheckClose(self):
126126

127127
def CheckExceptions(self):
128128
# Optional DB-API extension.
129-
self.failUnlessEqual(self.cx.Warning, sqlite.Warning)
130-
self.failUnlessEqual(self.cx.Error, sqlite.Error)
131-
self.failUnlessEqual(self.cx.InterfaceError, sqlite.InterfaceError)
132-
self.failUnlessEqual(self.cx.DatabaseError, sqlite.DatabaseError)
133-
self.failUnlessEqual(self.cx.DataError, sqlite.DataError)
134-
self.failUnlessEqual(self.cx.OperationalError, sqlite.OperationalError)
135-
self.failUnlessEqual(self.cx.IntegrityError, sqlite.IntegrityError)
136-
self.failUnlessEqual(self.cx.InternalError, sqlite.InternalError)
137-
self.failUnlessEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
138-
self.failUnlessEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
129+
self.assertEqual(self.cx.Warning, sqlite.Warning)
130+
self.assertEqual(self.cx.Error, sqlite.Error)
131+
self.assertEqual(self.cx.InterfaceError, sqlite.InterfaceError)
132+
self.assertEqual(self.cx.DatabaseError, sqlite.DatabaseError)
133+
self.assertEqual(self.cx.DataError, sqlite.DataError)
134+
self.assertEqual(self.cx.OperationalError, sqlite.OperationalError)
135+
self.assertEqual(self.cx.IntegrityError, sqlite.IntegrityError)
136+
self.assertEqual(self.cx.InternalError, sqlite.InternalError)
137+
self.assertEqual(self.cx.ProgrammingError, sqlite.ProgrammingError)
138+
self.assertEqual(self.cx.NotSupportedError, sqlite.NotSupportedError)
139139

140140
class CursorTests(unittest.TestCase):
141141
def setUp(self):
@@ -227,7 +227,7 @@ def CheckExecuteParamList(self):
227227
self.cu.execute("insert into test(name) values ('foo')")
228228
self.cu.execute("select name from test where name=?", ["foo"])
229229
row = self.cu.fetchone()
230-
self.failUnlessEqual(row[0], "foo")
230+
self.assertEqual(row[0], "foo")
231231

232232
def CheckExecuteParamSequence(self):
233233
class L(object):
@@ -240,13 +240,13 @@ def __getitem__(self, x):
240240
self.cu.execute("insert into test(name) values ('foo')")
241241
self.cu.execute("select name from test where name=?", L())
242242
row = self.cu.fetchone()
243-
self.failUnlessEqual(row[0], "foo")
243+
self.assertEqual(row[0], "foo")
244244

245245
def CheckExecuteDictMapping(self):
246246
self.cu.execute("insert into test(name) values ('foo')")
247247
self.cu.execute("select name from test where name=:name", {"name": "foo"})
248248
row = self.cu.fetchone()
249-
self.failUnlessEqual(row[0], "foo")
249+
self.assertEqual(row[0], "foo")
250250

251251
def CheckExecuteDictMapping_Mapping(self):
252252
class D(dict):
@@ -256,7 +256,7 @@ def __missing__(self, key):
256256
self.cu.execute("insert into test(name) values ('foo')")
257257
self.cu.execute("select name from test where name=:name", D())
258258
row = self.cu.fetchone()
259-
self.failUnlessEqual(row[0], "foo")
259+
self.assertEqual(row[0], "foo")
260260

261261
def CheckExecuteDictMappingTooLittleArgs(self):
262262
self.cu.execute("insert into test(name) values ('foo')")
@@ -290,7 +290,7 @@ def CheckRowcountExecute(self):
290290
self.cu.execute("insert into test(name) values ('foo')")
291291
self.cu.execute("insert into test(name) values ('foo')")
292292
self.cu.execute("update test set name='bar'")
293-
self.failUnlessEqual(self.cu.rowcount, 2)
293+
self.assertEqual(self.cu.rowcount, 2)
294294

295295
def CheckRowcountSelect(self):
296296
"""
@@ -299,12 +299,12 @@ def CheckRowcountSelect(self):
299299
has thus to be -1.
300300
"""
301301
self.cu.execute("select 5 union select 6")
302-
self.failUnlessEqual(self.cu.rowcount, -1)
302+
self.assertEqual(self.cu.rowcount, -1)
303303

304304
def CheckRowcountExecutemany(self):
305305
self.cu.execute("delete from test")
306306
self.cu.executemany("insert into test(name) values (?)", [(1,), (2,), (3,)])
307-
self.failUnlessEqual(self.cu.rowcount, 3)
307+
self.assertEqual(self.cu.rowcount, 3)
308308

309309
def CheckTotalChanges(self):
310310
self.cu.execute("insert into test(name) values ('foo')")
@@ -377,24 +377,24 @@ def CheckFetchIter(self):
377377
lst = []
378378
for row in self.cu:
379379
lst.append(row[0])
380-
self.failUnlessEqual(lst[0], 5)
381-
self.failUnlessEqual(lst[1], 6)
380+
self.assertEqual(lst[0], 5)
381+
self.assertEqual(lst[1], 6)
382382

383383
def CheckFetchone(self):
384384
self.cu.execute("select name from test")
385385
row = self.cu.fetchone()
386-
self.failUnlessEqual(row[0], "foo")
386+
self.assertEqual(row[0], "foo")
387387
row = self.cu.fetchone()
388-
self.failUnlessEqual(row, None)
388+
self.assertEqual(row, None)
389389

390390
def CheckFetchoneNoStatement(self):
391391
cur = self.cx.cursor()
392392
row = cur.fetchone()
393-
self.failUnlessEqual(row, None)
393+
self.assertEqual(row, None)
394394

395395
def CheckArraySize(self):
396396
# must default ot 1
397-
self.failUnlessEqual(self.cu.arraysize, 1)
397+
self.assertEqual(self.cu.arraysize, 1)
398398

399399
# now set to 2
400400
self.cu.arraysize = 2
@@ -407,27 +407,27 @@ def CheckArraySize(self):
407407
self.cu.execute("select name from test")
408408
res = self.cu.fetchmany()
409409

410-
self.failUnlessEqual(len(res), 2)
410+
self.assertEqual(len(res), 2)
411411

412412
def CheckFetchmany(self):
413413
self.cu.execute("select name from test")
414414
res = self.cu.fetchmany(100)
415-
self.failUnlessEqual(len(res), 1)
415+
self.assertEqual(len(res), 1)
416416
res = self.cu.fetchmany(100)
417-
self.failUnlessEqual(res, [])
417+
self.assertEqual(res, [])
418418

419419
def CheckFetchmanyKwArg(self):
420420
"""Checks if fetchmany works with keyword arguments"""
421421
self.cu.execute("select name from test")
422422
res = self.cu.fetchmany(size=100)
423-
self.failUnlessEqual(len(res), 1)
423+
self.assertEqual(len(res), 1)
424424

425425
def CheckFetchall(self):
426426
self.cu.execute("select name from test")
427427
res = self.cu.fetchall()
428-
self.failUnlessEqual(len(res), 1)
428+
self.assertEqual(len(res), 1)
429429
res = self.cu.fetchall()
430-
self.failUnlessEqual(res, [])
430+
self.assertEqual(res, [])
431431

432432
def CheckSetinputsizes(self):
433433
self.cu.setinputsizes([3, 4, 5])
@@ -440,7 +440,7 @@ def CheckSetoutputsizeNoColumn(self):
440440

441441
def CheckCursorConnection(self):
442442
# Optional DB-API extension.
443-
self.failUnlessEqual(self.cu.connection, self.cx)
443+
self.assertEqual(self.cu.connection, self.cx)
444444

445445
def CheckWrongCursorCallable(self):
446446
try:
@@ -651,7 +651,7 @@ def CheckScriptStringSql(self):
651651
""")
652652
cur.execute("select i from a")
653653
res = cur.fetchone()[0]
654-
self.failUnlessEqual(res, 5)
654+
self.assertEqual(res, 5)
655655

656656
def CheckScriptErrorIncomplete(self):
657657
con = sqlite.connect(":memory:")
@@ -661,7 +661,7 @@ def CheckScriptErrorIncomplete(self):
661661
cur.executescript("create table test(sadfsadfdsa")
662662
except sqlite.ProgrammingError:
663663
raised = True
664-
self.failUnlessEqual(raised, True, "should have raised an exception")
664+
self.assertEqual(raised, True, "should have raised an exception")
665665

666666
def CheckScriptErrorNormal(self):
667667
con = sqlite.connect(":memory:")
@@ -671,26 +671,26 @@ def CheckScriptErrorNormal(self):
671671
cur.executescript("create table test(sadfsadfdsa); select foo from hurz;")
672672
except sqlite.OperationalError:
673673
raised = True
674-
self.failUnlessEqual(raised, True, "should have raised an exception")
674+
self.assertEqual(raised, True, "should have raised an exception")
675675

676676
def CheckConnectionExecute(self):
677677
con = sqlite.connect(":memory:")
678678
result = con.execute("select 5").fetchone()[0]
679-
self.failUnlessEqual(result, 5, "Basic test of Connection.execute")
679+
self.assertEqual(result, 5, "Basic test of Connection.execute")
680680

681681
def CheckConnectionExecutemany(self):
682682
con = sqlite.connect(":memory:")
683683
con.execute("create table test(foo)")
684684
con.executemany("insert into test(foo) values (?)", [(3,), (4,)])
685685
result = con.execute("select foo from test order by foo").fetchall()
686-
self.failUnlessEqual(result[0][0], 3, "Basic test of Connection.executemany")
687-
self.failUnlessEqual(result[1][0], 4, "Basic test of Connection.executemany")
686+
self.assertEqual(result[0][0], 3, "Basic test of Connection.executemany")
687+
self.assertEqual(result[1][0], 4, "Basic test of Connection.executemany")
688688

689689
def CheckConnectionExecutescript(self):
690690
con = sqlite.connect(":memory:")
691691
con.executescript("create table test(foo); insert into test(foo) values (5);")
692692
result = con.execute("select foo from test").fetchone()[0]
693-
self.failUnlessEqual(result, 5, "Basic test of Connection.executescript")
693+
self.assertEqual(result, 5, "Basic test of Connection.executescript")
694694

695695
class ClosedTests(unittest.TestCase):
696696
def setUp(self):

‎Lib/sqlite3/test/factory.py‎

Lines changed: 30 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ def tearDown(self):
4747
self.con.close()
4848

4949
def CheckIsInstance(self):
50-
self.failUnless(isinstance(self.con,
50+
self.assertTrue(isinstance(self.con,
5151
MyConnection),
5252
"connection is not instance of MyConnection")
5353

@@ -60,7 +60,7 @@ def tearDown(self):
6060

6161
def CheckIsInstance(self):
6262
cur = self.con.cursor(factory=MyCursor)
63-
self.failUnless(isinstance(cur,
63+
self.assertTrue(isinstance(cur,
6464
MyCursor),
6565
"cursor is not instance of MyCursor")
6666

@@ -72,7 +72,7 @@ def CheckIsProducedByFactory(self):
7272
cur = self.con.cursor(factory=MyCursor)
7373
cur.execute("select 4+5 as foo")
7474
row = cur.fetchone()
75-
self.failUnless(isinstance(row,
75+
self.assertTrue(isinstance(row,
7676
dict),
7777
"row is not instance of dict")
7878
cur.close()
@@ -87,28 +87,28 @@ def setUp(self):
8787
def CheckCustomFactory(self):
8888
self.con.row_factory = lambda cur, row: list(row)
8989
row = self.con.execute("select 1, 2").fetchone()
90-
self.failUnless(isinstance(row,
90+
self.assertTrue(isinstance(row,
9191
list),
9292
"row is not instance of list")
9393

9494
def CheckSqliteRowIndex(self):
9595
self.con.row_factory = sqlite.Row
9696
row = self.con.execute("select 1 as a, 2 as b").fetchone()
97-
self.failUnless(isinstance(row,
97+
self.assertTrue(isinstance(row,
9898
sqlite.Row),
9999
"row is not instance of sqlite.Row")
100100

101101
col1, col2 = row["a"], row["b"]
102-
self.failUnless(col1 == 1, "by name: wrong result for column 'a'")
103-
self.failUnless(col2 == 2, "by name: wrong result for column 'a'")
102+
self.assertTrue(col1 == 1, "by name: wrong result for column 'a'")
103+
self.assertTrue(col2 == 2, "by name: wrong result for column 'a'")
104104

105105
col1, col2 = row["A"], row["B"]
106-
self.failUnless(col1 == 1, "by name: wrong result for column 'A'")
107-
self.failUnless(col2 == 2, "by name: wrong result for column 'B'")
106+
self.assertTrue(col1 == 1, "by name: wrong result for column 'A'")
107+
self.assertTrue(col2 == 2, "by name: wrong result for column 'B'")
108108

109109
col1, col2 = row[0], row[1]
110-
self.failUnless(col1 == 1, "by index: wrong result for column 0")
111-
self.failUnless(col2 == 2, "by index: wrong result for column 1")
110+
self.assertTrue(col1 == 1, "by index: wrong result for column 0")
111+
self.assertTrue(col2 == 2, "by index: wrong result for column 1")
112112

113113
def CheckSqliteRowIter(self):
114114
"""Checks if the row object is iterable"""
@@ -128,8 +128,8 @@ def CheckSqliteRowAsDict(self):
128128
self.con.row_factory = sqlite.Row
129129
row = self.con.execute("select 1 as a, 2 as b").fetchone()
130130
d = dict(row)
131-
self.failUnlessEqual(d["a"], row["a"])
132-
self.failUnlessEqual(d["b"], row["b"])
131+
self.assertEqual(d["a"], row["a"])
132+
self.assertEqual(d["b"], row["b"])
133133

134134
def CheckSqliteRowHashCmp(self):
135135
"""Checks if the row object compares and hashes correctly"""
@@ -138,18 +138,18 @@ def CheckSqliteRowHashCmp(self):
138138
row_2 = self.con.execute("select 1 as a, 2 as b").fetchone()
139139
row_3 = self.con.execute("select 1 as a, 3 as b").fetchone()
140140

141-
self.failUnless(row_1 == row_1)
142-
self.failUnless(row_1 == row_2)
143-
self.failUnless(row_2 != row_3)
141+
self.assertTrue(row_1 == row_1)
142+
self.assertTrue(row_1 == row_2)
143+
self.assertTrue(row_2 != row_3)
144144

145-
self.failIf(row_1 != row_1)
146-
self.failIf(row_1 != row_2)
147-
self.failIf(row_2 == row_3)
145+
self.assertFalse(row_1 != row_1)
146+
self.assertFalse(row_1 != row_2)
147+
self.assertFalse(row_2 == row_3)
148148

149-
self.failUnlessEqual(row_1, row_2)
150-
self.failUnlessEqual(hash(row_1), hash(row_2))
151-
self.failIfEqual(row_1, row_3)
152-
self.failIfEqual(hash(row_1), hash(row_3))
149+
self.assertEqual(row_1, row_2)
150+
self.assertEqual(hash(row_1), hash(row_2))
151+
self.assertNotEqual(row_1, row_3)
152+
self.assertNotEqual(hash(row_1), hash(row_3))
153153

154154
def tearDown(self):
155155
self.con.close()
@@ -161,30 +161,30 @@ def setUp(self):
161161
def CheckUnicode(self):
162162
austria = "Österreich"
163163
row = self.con.execute("select ?", (austria,)).fetchone()
164-
self.failUnless(type(row[0]) == str, "type of row[0] must be unicode")
164+
self.assertTrue(type(row[0]) == str, "type of row[0] must be unicode")
165165

166166
def CheckString(self):
167167
self.con.text_factory = bytes
168168
austria = "Österreich"
169169
row = self.con.execute("select ?", (austria,)).fetchone()
170-
self.failUnless(type(row[0]) == bytes, "type of row[0] must be bytes")
171-
self.failUnless(row[0] == austria.encode("utf-8"), "column must equal original data in UTF-8")
170+
self.assertTrue(type(row[0]) == bytes, "type of row[0] must be bytes")
171+
self.assertTrue(row[0] == austria.encode("utf-8"), "column must equal original data in UTF-8")
172172

173173
def CheckCustom(self):
174174
self.con.text_factory = lambda x: str(x, "utf-8", "ignore")
175175
austria = "Österreich"
176176
row = self.con.execute("select ?", (austria,)).fetchone()
177-
self.failUnless(type(row[0]) == str, "type of row[0] must be unicode")
178-
self.failUnless(row[0].endswith("reich"), "column must contain original data")
177+
self.assertTrue(type(row[0]) == str, "type of row[0] must be unicode")
178+
self.assertTrue(row[0].endswith("reich"), "column must contain original data")
179179

180180
def CheckOptimizedUnicode(self):
181181
self.con.text_factory = sqlite.OptimizedUnicode
182182
austria = "Österreich"
183183
germany = "Deutchland"
184184
a_row = self.con.execute("select ?", (austria,)).fetchone()
185185
d_row = self.con.execute("select ?", (germany,)).fetchone()
186-
self.failUnless(type(a_row[0]) == str, "type of non-ASCII row must be str")
187-
self.failUnless(type(d_row[0]) == str, "type of ASCII-only row must be str")
186+
self.assertTrue(type(a_row[0]) == str, "type of non-ASCII row must be str")
187+
self.assertTrue(type(d_row[0]) == str, "type of ASCII-only row must be str")
188188

189189
def tearDown(self):
190190
self.con.close()

0 commit comments

Comments
 (0)