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

Merged revisions 77871,77910,77913 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r77871 | ezio.melotti | 2010-01-31 13:46:54 +0200 (Sun, 31 Jan 2010) | 1 line

  #7092: silence more -3 and -Wd warnings
........
  r77910 | ezio.melotti | 2010-02-02 10:37:35 +0200 (Tue, 02 Feb 2010) | 1 line

  #7092: silence py3k warnings for bsddb. Patch by Florent Xicluna.
........
  r77913 | ezio.melotti | 2010-02-02 19:34:37 +0200 (Tue, 02 Feb 2010) | 1 line

  #7092: Silence py3k warnings in test_exceptions and test_pep352. Patch by Florent Xicluna.
........
This commit is contained in:
Ezio Melotti 2010-08-02 03:14:27 +00:00
parent 9c4fbdbc55
commit 38a5800cdc
15 changed files with 162 additions and 182 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
Lib/bsddb/dbtables.py
View File

@ -332,7 +332,7 @@ class bsdTableDB :
except db.DBError, dberror:
if txn:
txn.abort()
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
raise TableDBError, dberror[1]
else :
raise TableDBError, dberror.args[1]
@ -416,7 +416,7 @@ class bsdTableDB :
except db.DBError, dberror:
if txn:
txn.abort()
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
raise TableDBError, dberror[1]
else :
raise TableDBError, dberror.args[1]
@ -499,7 +499,7 @@ class bsdTableDB :
if txn:
txn.abort()
self.db.delete(_rowid_key(table, rowid))
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
raise TableDBError, dberror[1], info[2]
else :
raise TableDBError, dberror.args[1], info[2]
@ -554,7 +554,7 @@ class bsdTableDB :
raise
except db.DBError, dberror:
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
raise TableDBError, dberror[1]
else :
raise TableDBError, dberror.args[1]
@ -598,7 +598,7 @@ class bsdTableDB :
txn.abort()
raise
except db.DBError, dberror:
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
raise TableDBError, dberror[1]
else :
raise TableDBError, dberror.args[1]
@ -621,7 +621,7 @@ class bsdTableDB :
columns = self.__tablecolumns[table]
matching_rowids = self.__Select(table, columns, conditions)
except db.DBError, dberror:
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
raise TableDBError, dberror[1]
else :
raise TableDBError, dberror.args[1]
@ -677,7 +677,7 @@ class bsdTableDB :
# leave all unknown condition callables alone as equals
return 0
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
conditionlist = conditions.items()
conditionlist.sort(cmp_conditions)
else : # Insertion Sort. Please, improve
@ -749,7 +749,7 @@ class bsdTableDB :
rowdata[column] = self.db.get(
_data_key(table, column, rowid))
except db.DBError, dberror:
if sys.version_info[0] < 3 :
if sys.version_info < (2, 6) :
if dberror[0] != db.DB_NOTFOUND:
raise
else :

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

@ -139,11 +139,7 @@ class BasicTestCase(unittest.TestCase):
try:
d.delete('abcd')
except db.DBNotFoundError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_NOTFOUND)
else :
self.assertEqual(val.args[0], db.DB_NOTFOUND)
self.assertEqual(val.args[0], db.DB_NOTFOUND)
if verbose: print val
else:
self.fail("expected exception")
@ -162,11 +158,7 @@ class BasicTestCase(unittest.TestCase):
try:
d.put('abcd', 'this should fail', flags=db.DB_NOOVERWRITE)
except db.DBKeyExistError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_KEYEXIST)
else :
self.assertEqual(val.args[0], db.DB_KEYEXIST)
self.assertEqual(val.args[0], db.DB_KEYEXIST)
if verbose: print val
else:
self.fail("expected exception")
@ -301,11 +293,7 @@ class BasicTestCase(unittest.TestCase):
rec = c.next()
except db.DBNotFoundError, val:
if get_raises_error:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_NOTFOUND)
else :
self.assertEqual(val.args[0], db.DB_NOTFOUND)
self.assertEqual(val.args[0], db.DB_NOTFOUND)
if verbose: print val
rec = None
else:
@ -326,11 +314,7 @@ class BasicTestCase(unittest.TestCase):
rec = c.prev()
except db.DBNotFoundError, val:
if get_raises_error:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_NOTFOUND)
else :
self.assertEqual(val.args[0], db.DB_NOTFOUND)
self.assertEqual(val.args[0], db.DB_NOTFOUND)
if verbose: print val
rec = None
else:
@ -353,11 +337,7 @@ class BasicTestCase(unittest.TestCase):
try:
n = c.set('bad key')
except db.DBNotFoundError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_NOTFOUND)
else :
self.assertEqual(val.args[0], db.DB_NOTFOUND)
self.assertEqual(val.args[0], db.DB_NOTFOUND)
if verbose: print val
else:
if set_raises_error:
@ -371,11 +351,7 @@ class BasicTestCase(unittest.TestCase):
try:
n = c.get_both('0404', 'bad data')
except db.DBNotFoundError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_NOTFOUND)
else :
self.assertEqual(val.args[0], db.DB_NOTFOUND)
self.assertEqual(val.args[0], db.DB_NOTFOUND)
if verbose: print val
else:
if get_raises_error:
@ -404,11 +380,7 @@ class BasicTestCase(unittest.TestCase):
rec = c.current()
except db.DBKeyEmptyError, val:
if get_raises_error:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.DB_KEYEMPTY)
else :
self.assertEqual(val.args[0], db.DB_KEYEMPTY)
self.assertEqual(val.args[0], db.DB_KEYEMPTY)
if verbose: print val
else:
self.fail("unexpected DBKeyEmptyError")
@ -451,13 +423,9 @@ class BasicTestCase(unittest.TestCase):
print "attempting to use a closed cursor's %s method" % \
method
# a bug may cause a NULL pointer dereference...
apply(getattr(c, method), args)
getattr(c, method)(*args)
except db.DBError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], 0)
else :
self.assertEqual(val.args[0], 0)
self.assertEqual(val.args[0], 0)
if verbose: print val
else:
self.fail("no exception raised when using a buggy cursor's"
@ -710,10 +678,10 @@ class BasicTransactionTestCase(BasicTestCase):
pass
statDict = self.env.log_stat(0);
self.assert_(statDict.has_key('magic'))
self.assert_(statDict.has_key('version'))
self.assert_(statDict.has_key('cur_file'))
self.assert_(statDict.has_key('region_nowait'))
self.assertTrue('magic' in statDict)
self.assertTrue('version' in statDict)
self.assertTrue('cur_file' in statDict)
self.assertTrue('region_nowait' in statDict)
# must have at least one log file present:
logs = self.env.log_archive(db.DB_ARCH_ABS | db.DB_ARCH_LOG)

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

@ -30,7 +30,7 @@ class ComparatorTests (unittest.TestCase):
data = expected_data[:]
import sys
if sys.version_info[0] < 3 :
if sys.version_info[:3] < (2, 6, 0):
if sys.version_info[:3] < (2, 4, 0):
data.sort(comparator)
else :
@ -47,7 +47,7 @@ class ComparatorTests (unittest.TestCase):
data2.append(i)
data = data2
self.failUnless (data == expected_data,
self.assertEqual (data, expected_data,
"comparator `%s' is not right: %s vs. %s"
% (comparator, expected_data, data))
def test_lexical_comparator (self):
@ -115,14 +115,14 @@ class AbstractBtreeKeyCompareTestCase (unittest.TestCase):
rec = curs.first ()
while rec:
key, ignore = rec
self.failUnless (index < len (expected),
self.assertTrue (index < len (expected),
"to many values returned from cursor")
self.failUnless (expected[index] == key,
self.assertEqual (expected[index], key,
"expected value `%s' at %d but got `%s'"
% (expected[index], index, key))
index = index + 1
rec = curs.next ()
self.failUnless (index == len (expected),
self.assertEqual (index, len (expected),
"not enough values returned from cursor")
finally:
curs.close ()

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

@ -27,7 +27,7 @@ class dbobjTestCase(unittest.TestCase):
def put(self, key, *args, **kwargs):
key = key.upper()
# call our parent classes put method with an upper case key
return apply(dbobj.DB.put, (self, key) + args, kwargs)
return dbobj.DB.put(self, key, *args, **kwargs)
self.env = TestDBEnv()
self.env.open(self.homeDir, db.DB_CREATE | db.DB_INIT_MPOOL)
self.db = TestDB(self.env)

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

@ -5,6 +5,7 @@ TestCases for checking dbShelve objects.
import os, string
import random
import unittest
import warnings
from test_all import db, dbshelve, test_support, verbose, \
@ -117,15 +118,11 @@ class DBShelveTestCase(unittest.TestCase):
dbvalues = d.values()
self.assertEqual(len(dbvalues), len(d.keys()))
import sys
if sys.version_info[0] < 3 :
values.sort()
dbvalues.sort()
self.assertEqual(values, dbvalues)
else : # XXX: Convert all to strings. Please, improve
values.sort(key=lambda x : str(x))
dbvalues.sort(key=lambda x : str(x))
self.assertEqual(repr(values), repr(dbvalues))
with warnings.catch_warnings():
warnings.filterwarnings('ignore',
'comparing unequal types not supported',
DeprecationWarning)
self.assertEqual(sorted(values), sorted(dbvalues))
items = d.items()
self.assertEqual(len(items), len(values))

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

@ -51,13 +51,13 @@ class JoinTestCase(unittest.TestCase):
# create and populate primary index
priDB = db.DB(self.env)
priDB.open(self.filename, "primary", db.DB_BTREE, db.DB_CREATE)
map(lambda t, priDB=priDB: apply(priDB.put, t), ProductIndex)
map(lambda t, priDB=priDB: priDB.put(*t), ProductIndex)
# create and populate secondary index
secDB = db.DB(self.env)
secDB.set_flags(db.DB_DUP | db.DB_DUPSORT)
secDB.open(self.filename, "secondary", db.DB_BTREE, db.DB_CREATE)
map(lambda t, secDB=secDB: apply(secDB.put, t), ColorIndex)
map(lambda t, secDB=secDB: secDB.put(*t), ColorIndex)
sCursor = None
jCursor = None

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

@ -60,11 +60,7 @@ class SimpleRecnoTestCase(unittest.TestCase):
try:
data = d[0] # This should raise a KeyError!?!?!
except db.DBInvalidArgError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.EINVAL)
else :
self.assertEqual(val.args[0], db.EINVAL)
self.assertEqual(val.args[0], db.EINVAL)
if verbose: print val
else:
self.fail("expected exception")
@ -269,11 +265,7 @@ class SimpleRecnoTestCase(unittest.TestCase):
try: # this one will fail
d.append('bad' * 20)
except db.DBInvalidArgError, val:
import sys
if sys.version_info[0] < 3 :
self.assertEqual(val[0], db.EINVAL)
else :
self.assertEqual(val.args[0], db.EINVAL)
self.assertEqual(val.args[0], db.EINVAL)
if verbose: print val
else:
self.fail("expected exception")

2
Lib/cgi.py
View File

@ -172,7 +172,7 @@ def parse(fp=None, environ=os.environ, keep_blank_values=0, strict_parsing=0):
else:
qs = ""
environ['QUERY_STRING'] = qs # XXX Shouldn't, really
return parse_qs(qs, keep_blank_values, strict_parsing)
return urlparse.parse_qs(qs, keep_blank_values, strict_parsing)
# parse query string function called from urlparse,

8
Lib/test/test_bsddb3.py
View File

@ -7,7 +7,13 @@ import sys
import tempfile
import time
import unittest
from test.test_support import requires, verbose, run_unittest, unlink, rmtree
from test.test_support import (requires, verbose, run_unittest, unlink, rmtree,
import_module)
# Skip test if _bsddb module was not built.
import_module('_bsddb')
# Silence Py3k warning
import_module('bsddb', deprecated=True)
# When running as a script instead of within the regrtest framework, skip the
# requires test, since it's obvious we want to run them.

43
Lib/test/test_cgi.py
View File

@ -1,4 +1,4 @@
from test.test_support import run_unittest
from test.test_support import run_unittest, check_warnings
import cgi
import os
import sys
@ -102,11 +102,6 @@ parse_strict_test_cases = [
})
]
def norm(list):
if type(list) == type([]):
list.sort()
return list
def first_elts(list):
return map(lambda x:x[0], list)
@ -141,18 +136,18 @@ class CgiTests(unittest.TestCase):
if type(expect) == type({}):
# test dict interface
self.assertEqual(len(expect), len(fcd))
self.assertEqual(norm(expect.keys()), norm(fcd.keys()))
self.assertEqual(norm(expect.values()), norm(fcd.values()))
self.assertEqual(norm(expect.items()), norm(fcd.items()))
self.assertEqual(sorted(expect.keys()), sorted(fcd.keys()))
self.assertEqual(sorted(expect.values()), sorted(fcd.values()))
self.assertEqual(sorted(expect.items()), sorted(fcd.items()))
self.assertEqual(fcd.get("nonexistent field", "default"), "default")
self.assertEqual(len(sd), len(fs))
self.assertEqual(norm(sd.keys()), norm(fs.keys()))
self.assertEqual(sorted(sd.keys()), sorted(fs.keys()))
self.assertEqual(fs.getvalue("nonexistent field", "default"), "default")
# test individual fields
for key in expect.keys():
expect_val = expect[key]
self.assert_(fcd.has_key(key))
self.assertEqual(norm(fcd[key]), norm(expect[key]))
self.assertEqual(sorted(fcd[key]), sorted(expect[key]))
self.assertEqual(fcd.get(key, "default"), fcd[key])
self.assert_(fs.has_key(key))
if len(expect_val) > 1:
@ -168,12 +163,12 @@ class CgiTests(unittest.TestCase):
self.assert_(single_value)
self.assertEqual(val, expect_val[0])
self.assertEqual(fs.getvalue(key), expect_val[0])
self.assertEqual(norm(sd.getlist(key)), norm(expect_val))
self.assertEqual(sorted(sd.getlist(key)), sorted(expect_val))
if single_value:
self.assertEqual(norm(sd.values()),
first_elts(norm(expect.values())))
self.assertEqual(norm(sd.items()),
first_second_elts(norm(expect.items())))
self.assertEqual(sorted(sd.values()),
sorted(first_elts(expect.values())))
self.assertEqual(sorted(sd.items()),
sorted(first_second_elts(expect.items())))
def test_weird_formcontentdict(self):
# Test the weird FormContentDict classes
@ -184,7 +179,7 @@ class CgiTests(unittest.TestCase):
self.assertEqual(d[k], v)
for k, v in d.items():
self.assertEqual(expect[k], v)
self.assertEqual(norm(expect.values()), norm(d.values()))
self.assertEqual(sorted(expect.values()), sorted(d.values()))
def test_log(self):
cgi.log("Testing")
@ -345,14 +340,16 @@ this is the content of the fake file
self.assertEqual(result, v)
def test_deprecated_parse_qs(self):
# this func is moved to urlparse, this is just a sanity check
self.assertEqual({'a': ['A1'], 'B': ['B3'], 'b': ['B2']},
cgi.parse_qs('a=A1&b=B2&B=B3'))
with check_warnings():
# this func is moved to urlparse, this is just a sanity check
self.assertEqual({'a': ['A1'], 'B': ['B3'], 'b': ['B2']},
cgi.parse_qs('a=A1&b=B2&B=B3'))
def test_deprecated_parse_qsl(self):
# this func is moved to urlparse, this is just a sanity check
self.assertEqual([('a', 'A1'), ('b', 'B2'), ('B', 'B3')],
cgi.parse_qsl('a=A1&b=B2&B=B3'))
with check_warnings():
# this func is moved to urlparse, this is just a sanity check
self.assertEqual([('a', 'A1'), ('b', 'B2'), ('B', 'B3')],
cgi.parse_qsl('a=A1&b=B2&B=B3'))
def test_parse_header(self):
self.assertEqual(

17
Lib/test/test_coercion.py
View File

@ -223,8 +223,10 @@ def process_infix_results():
infix_results[key] = res
process_infix_results()
with warnings.catch_warnings():
warnings.filterwarnings("ignore", "classic int division",
DeprecationWarning)
process_infix_results()
# now infix_results has two lists of results for every pairing.
prefix_binops = [ 'divmod' ]
@ -337,11 +339,12 @@ class CoercionTest(unittest.TestCase):
raise exc
def test_main():
warnings.filterwarnings("ignore",
r'complex divmod\(\), // and % are deprecated',
DeprecationWarning,
r'test.test_coercion$')
run_unittest(CoercionTest)
with warnings.catch_warnings():
warnings.filterwarnings("ignore", "complex divmod.., // and % "
"are deprecated", DeprecationWarning)
warnings.filterwarnings("ignore", "classic (int|long) division",
DeprecationWarning)
run_unittest(CoercionTest)
if __name__ == "__main__":
test_main()

7
Lib/test/test_distutils.py
View File

@ -7,10 +7,15 @@ be run.
import distutils.tests
import test.test_support
import warnings
def test_main():
test.test_support.run_unittest(distutils.tests.test_suite())
with warnings.catch_warnings():
warnings.filterwarnings("ignore",
"distutils.sysconfig.\w+ is deprecated",
DeprecationWarning)
test.test_support.run_unittest(distutils.tests.test_suite())
if __name__ == "__main__":

67
Lib/test/test_exceptions.py
View File

@ -7,7 +7,7 @@ import pickle, cPickle
import warnings
from test.test_support import TESTFN, unlink, run_unittest, captured_output
from test.test_pep352 import ignore_message_warning
from test.test_pep352 import ignore_deprecation_warnings
# XXX This is not really enough, each *operation* should be tested!
@ -17,6 +17,7 @@ class ExceptionTests(unittest.TestCase):
# Reloading the built-in exceptions module failed prior to Py2.2, while it
# should act the same as reloading built-in sys.
try:
from imp import reload
import exceptions
reload(exceptions)
except ImportError, e:
@ -108,11 +109,11 @@ class ExceptionTests(unittest.TestCase):
self.assertRaises(ValueError, chr, 10000)
self.raise_catch(ZeroDivisionError, "ZeroDivisionError")
try: x = 1/0
try: x = 1 // 0
except ZeroDivisionError: pass
self.raise_catch(Exception, "Exception")
try: x = 1/0
try: x = 1 // 0
except Exception, e: pass
def testSyntaxErrorMessage(self):
@ -197,6 +198,7 @@ class ExceptionTests(unittest.TestCase):
self.failUnlessEqual(WindowsError(1001, "message").errno, 22)
self.failUnlessEqual(WindowsError(1001, "message").winerror, 1001)
@ignore_deprecation_warnings
def testAttributes(self):
# test that exception attributes are happy
@ -274,34 +276,32 @@ class ExceptionTests(unittest.TestCase):
except NameError:
pass
with warnings.catch_warnings():
ignore_message_warning()
for exc, args, expected in exceptionList:
try:
raise exc(*args)
except BaseException, e:
if type(e) is not exc:
raise
# Verify module name
self.assertEquals(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))
for exc, args, expected in exceptionList:
try:
raise exc(*args)
except BaseException, e:
if type(e) is not exc:
raise
# Verify module name
self.assertEquals(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))
# test for pickling support
for p in pickle, cPickle:
for protocol in range(p.HIGHEST_PROTOCOL + 1):
new = p.loads(p.dumps(e, protocol))
for checkArgName in expected:
got = repr(getattr(new, checkArgName))
want = repr(expected[checkArgName])
self.assertEquals(got, want,
'pickled "%r", attribute "%s"' %
(e, checkArgName))
# test for pickling support
for p in pickle, cPickle:
for protocol in range(p.HIGHEST_PROTOCOL + 1):
new = p.loads(p.dumps(e, protocol))
for checkArgName in expected:
got = repr(getattr(new, checkArgName))
want = repr(expected[checkArgName])
self.assertEquals(got, want,
'pickled "%r", attribute "%s"' %
(e, checkArgName))
def testDeprecatedMessageAttribute(self):
@ -329,6 +329,7 @@ class ExceptionTests(unittest.TestCase):
del exc.message
self.assertRaises(AttributeError, getattr, exc, "message")
@ignore_deprecation_warnings
def testPickleMessageAttribute(self):
# Pickling with message attribute must work, as well.
e = Exception("foo")
@ -336,18 +337,18 @@ class ExceptionTests(unittest.TestCase):
f.message = "bar"
for p in pickle, cPickle:
ep = p.loads(p.dumps(e))
with warnings.catch_warnings():
ignore_message_warning()
self.assertEqual(ep.message, "foo")
self.assertEqual(ep.message, "foo")
fp = p.loads(p.dumps(f))
self.assertEqual(fp.message, "bar")
@ignore_deprecation_warnings
def testSlicing(self):
# Test that you can slice an exception directly instead of requiring
# going through the 'args' attribute.
args = (1, 2, 3)
exc = BaseException(*args)
self.failUnlessEqual(exc[:], args)
self.assertEqual(exc.args[:], args)
def testKeywordArgs(self):
# test that builtin exception don't take keyword args,

78
Lib/test/test_pep352.py
View File

@ -4,14 +4,27 @@ import exceptions
import warnings
from test.test_support import run_unittest
import os
import sys
from platform import system as platform_system
def ignore_message_warning():
"""Ignore the DeprecationWarning for BaseException.message."""
warnings.resetwarnings()
warnings.filterwarnings("ignore", "BaseException.message",
DeprecationWarning)
DEPRECATION_WARNINGS = ["BaseException.message has been deprecated"]
if sys.py3kwarning:
DEPRECATION_WARNINGS.extend(
["exceptions must derive from BaseException",
"catching classes that don't inherit from BaseException is not allowed",
"__get(item|slice)__ not supported for exception classes"])
# Silence Py3k and other deprecation warnings
def ignore_deprecation_warnings(func):
"""Ignore the known DeprecationWarnings."""
def wrapper(*args, **kw):
with warnings.catch_warnings():
warnings.resetwarnings()
for text in DEPRECATION_WARNINGS:
warnings.filterwarnings("ignore", text, DeprecationWarning)
return func(*args, **kw)
return wrapper
class ExceptionClassTests(unittest.TestCase):
@ -21,13 +34,11 @@ class ExceptionClassTests(unittest.TestCase):
def test_builtins_new_style(self):
self.failUnless(issubclass(Exception, object))
@ignore_deprecation_warnings
def verify_instance_interface(self, ins):
with warnings.catch_warnings():
ignore_message_warning()
for attr in ("args", "message", "__str__", "__repr__",
"__getitem__"):
self.failUnless(hasattr(ins, attr),
"%s missing %s attribute" %
for attr in ("args", "message", "__str__", "__repr__", "__getitem__"):
self.assertTrue(hasattr(ins, attr),
"%s missing %s attribute" %
(ins.__class__.__name__, attr))
def test_inheritance(self):
@ -91,43 +102,39 @@ class ExceptionClassTests(unittest.TestCase):
self.failUnlessEqual(given, expected, "%s: %s != %s" % (test_name,
given, expected))
@ignore_deprecation_warnings
def test_interface_single_arg(self):
# Make sure interface works properly when given a single argument
arg = "spam"
exc = Exception(arg)
with warnings.catch_warnings():
ignore_message_warning()
results = ([len(exc.args), 1], [exc.args[0], arg],
[exc.message, arg],
[str(exc), str(arg)], [unicode(exc), unicode(arg)],
[repr(exc), exc.__class__.__name__ + repr(exc.args)], [exc[0],
arg])
self.interface_test_driver(results)
results = ([len(exc.args), 1], [exc.args[0], arg], [exc.message, arg],
[str(exc), str(arg)], [unicode(exc), unicode(arg)],
[repr(exc), exc.__class__.__name__ + repr(exc.args)],
[exc[0], arg])
self.interface_test_driver(results)
@ignore_deprecation_warnings
def test_interface_multi_arg(self):
# Make sure interface correct when multiple arguments given
arg_count = 3
args = tuple(range(arg_count))
exc = Exception(*args)
with warnings.catch_warnings():
ignore_message_warning()
results = ([len(exc.args), arg_count], [exc.args, args],
[exc.message, ''], [str(exc), str(args)],
[unicode(exc), unicode(args)],
[repr(exc), exc.__class__.__name__ + repr(exc.args)],
[exc[-1], args[-1]])
self.interface_test_driver(results)
results = ([len(exc.args), arg_count], [exc.args, args],
[exc.message, ''], [str(exc), str(args)],
[unicode(exc), unicode(args)],
[repr(exc), exc.__class__.__name__ + repr(exc.args)],
[exc[-1], args[-1]])
self.interface_test_driver(results)
@ignore_deprecation_warnings
def test_interface_no_arg(self):
# Make sure that with no args that interface is correct
exc = Exception()
with warnings.catch_warnings():
ignore_message_warning()
results = ([len(exc.args), 0], [exc.args, tuple()],
[exc.message, ''],
[str(exc), ''], [unicode(exc), u''],
[repr(exc), exc.__class__.__name__ + '()'], [True, True])
self.interface_test_driver(results)
results = ([len(exc.args), 0], [exc.args, tuple()],
[exc.message, ''],
[str(exc), ''], [unicode(exc), u''],
[repr(exc), exc.__class__.__name__ + '()'], [True, True])
self.interface_test_driver(results)
def test_message_deprecation(self):
@ -179,6 +186,7 @@ class UsageTests(unittest.TestCase):
self.fail("TypeError expected when catching %s as specified in a "
"tuple" % type(object_))
@ignore_deprecation_warnings
def test_raise_classic(self):
# Raising a classic class is okay (for now).
class ClassicClass:
@ -194,7 +202,7 @@ class UsageTests(unittest.TestCase):
except ClassicClass:
pass
except:
self.fail("unable to raise class class instance")
self.fail("unable to raise classic class instance")
def test_raise_new_style_non_exception(self):
# You cannot raise a new-style class that does not inherit from

5
Lib/test/test_userstring.py
View File

@ -136,7 +136,10 @@ class MutableStringTest(UserStringTest):
def test_main():
with warnings.catch_warnings():
warnings.filterwarnings("ignore", ".*MutableString",
warnings.filterwarnings("ignore", ".*MutableString has been removed",
DeprecationWarning)
warnings.filterwarnings("ignore",
".*__(get|set|del)slice__ has been removed",
DeprecationWarning)
test_support.run_unittest(UserStringTest, MutableStringTest)