import unittest
import sys
-from test.test_support import CleanImport, TestSkipped, run_unittest
+from test.test_support import (check_warnings, CleanImport,
+ TestSkipped, run_unittest)
import warnings
from contextlib import nested
if not sys.py3kwarning:
raise TestSkipped('%s must be run with the -3 flag' % __name__)
+def reset_module_registry(module):
+ try:
+ registry = module.__warningregistry__
+ except AttributeError:
+ pass
+ else:
+ registry.clear()
class TestPy3KWarnings(unittest.TestCase):
def assertWarning(self, _, warning, expected_message):
- self.assertEqual(str(warning[-1].message), expected_message)
+ self.assertEqual(str(warning.message), expected_message)
def test_backquote(self):
expected = 'backquote not supported in 3.x; use repr()'
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
exec "`2`" in {}
self.assertWarning(None, w, expected)
exec expr in {'f' : f}
expected = "assignment to True or False is forbidden in 3.x"
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
safe_exec("True = False")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("False = True")
self.assertWarning(None, w, expected)
+ w.reset()
try:
safe_exec("obj.False = True")
except NameError: pass
self.assertWarning(None, w, expected)
+ w.reset()
try:
safe_exec("obj.True = False")
except NameError: pass
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("def False(): pass")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("def True(): pass")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("class False: pass")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("class True: pass")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("def f(True=43): pass")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("def f(False=None): pass")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("f(False=True)")
self.assertWarning(None, w, expected)
+ w.reset()
safe_exec("f(True=1)")
self.assertWarning(None, w, expected)
def test_type_inequality_comparisons(self):
expected = 'type inequality comparisons not supported in 3.x'
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(int < str, w, expected)
+ w.reset()
self.assertWarning(type < object, w, expected)
def test_object_inequality_comparisons(self):
expected = 'comparing unequal types not supported in 3.x'
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(str < [], w, expected)
+ w.reset()
self.assertWarning(object() < (1, 2), w, expected)
def test_dict_inequality_comparisons(self):
expected = 'dict inequality comparisons not supported in 3.x'
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning({} < {2:3}, w, expected)
+ w.reset()
self.assertWarning({} <= {}, w, expected)
+ w.reset()
self.assertWarning({} > {2:3}, w, expected)
+ w.reset()
self.assertWarning({2:3} >= {}, w, expected)
def test_cell_inequality_comparisons(self):
return g
cell0, = f(0).func_closure
cell1, = f(1).func_closure
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(cell0 == cell1, w, expected)
+ w.reset()
self.assertWarning(cell0 < cell1, w, expected)
def test_code_inequality_comparisons(self):
pass
def g(x):
pass
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(f.func_code < g.func_code, w, expected)
+ w.reset()
self.assertWarning(f.func_code <= g.func_code, w, expected)
+ w.reset()
self.assertWarning(f.func_code >= g.func_code, w, expected)
+ w.reset()
self.assertWarning(f.func_code > g.func_code, w, expected)
def test_builtin_function_or_method_comparisons(self):
'inequality comparisons not supported in 3.x')
func = eval
meth = {}.get
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(func < meth, w, expected)
+ w.reset()
self.assertWarning(func > meth, w, expected)
+ w.reset()
self.assertWarning(meth <= func, w, expected)
+ w.reset()
self.assertWarning(meth >= func, w, expected)
def test_sort_cmp_arg(self):
lst = range(5)
cmp = lambda x,y: -1
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(lst.sort(cmp=cmp), w, expected)
+ w.reset()
self.assertWarning(sorted(lst, cmp=cmp), w, expected)
+ w.reset()
self.assertWarning(lst.sort(cmp), w, expected)
+ w.reset()
self.assertWarning(sorted(lst, cmp), w, expected)
def test_sys_exc_clear(self):
expected = 'sys.exc_clear() not supported in 3.x; use except clauses'
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(sys.exc_clear(), w, expected)
def test_methods_members(self):
__methods__ = ['a']
__members__ = ['b']
c = C()
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(dir(c), w, expected)
def test_softspace(self):
expected = 'file.softspace not supported in 3.x'
with file(__file__) as f:
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(f.softspace, w, expected)
def set():
f.softspace = 0
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(set(), w, expected)
def test_slice_methods(self):
expected = "in 3.x, __{0}slice__ has been removed; use __{0}item__"
for obj in (Spam(), Egg()):
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(obj[1:2], w, expected.format('get'))
+ w.reset()
del obj[3:4]
self.assertWarning(None, w, expected.format('del'))
+ w.reset()
obj[4:5] = "eggs"
self.assertWarning(None, w, expected.format('set'))
def test_tuple_parameter_unpacking(self):
expected = "tuple parameter unpacking has been removed in 3.x"
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
exec "def f((a, b)): pass"
self.assertWarning(None, w, expected)
def test_buffer(self):
expected = 'buffer() not supported in 3.x'
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(buffer('a'), w, expected)
def test_file_xreadlines(self):
expected = ("f.xreadlines() not supported in 3.x, "
"try 'for line in f' instead")
with file(__file__) as f:
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
self.assertWarning(f.xreadlines(), w, expected)
def test_hash_inheritance(self):
- with warnings.catch_warnings(record=True) as w:
+ with check_warnings() as w:
# With object as the base class
class WarnOnlyCmp(object):
def __cmp__(self, other): pass
- self.assertEqual(len(w), 1)
+ self.assertEqual(len(w.warnings), 1)
self.assertWarning(None, w,
"Overriding __cmp__ blocks inheritance of __hash__ in 3.x")
- del w[:]
+ w.reset()
class WarnOnlyEq(object):
def __eq__(self, other): pass
- self.assertEqual(len(w), 1)
+ self.assertEqual(len(w.warnings), 1)
self.assertWarning(None, w,
"Overriding __eq__ blocks inheritance of __hash__ in 3.x")
- del w[:]
+ w.reset()
class WarnCmpAndEq(object):
def __cmp__(self, other): pass
def __eq__(self, other): pass
- self.assertEqual(len(w), 2)
- self.assertWarning(None, w[:1],
+ self.assertEqual(len(w.warnings), 2)
+ self.assertWarning(None, w.warnings[0],
"Overriding __cmp__ blocks inheritance of __hash__ in 3.x")
self.assertWarning(None, w,
"Overriding __eq__ blocks inheritance of __hash__ in 3.x")
- del w[:]
+ w.reset()
class NoWarningOnlyHash(object):
def __hash__(self): pass
- self.assertEqual(len(w), 0)
- del w[:]
+ self.assertEqual(len(w.warnings), 0)
# With an intermediate class in the heirarchy
class DefinesAllThree(object):
def __cmp__(self, other): pass
def __hash__(self): pass
class WarnOnlyCmp(DefinesAllThree):
def __cmp__(self, other): pass
- self.assertEqual(len(w), 1)
+ self.assertEqual(len(w.warnings), 1)
self.assertWarning(None, w,
"Overriding __cmp__ blocks inheritance of __hash__ in 3.x")
- del w[:]
+ w.reset()
class WarnOnlyEq(DefinesAllThree):
def __eq__(self, other): pass
- self.assertEqual(len(w), 1)
+ self.assertEqual(len(w.warnings), 1)
self.assertWarning(None, w,
"Overriding __eq__ blocks inheritance of __hash__ in 3.x")
- del w[:]
+ w.reset()
class WarnCmpAndEq(DefinesAllThree):
def __cmp__(self, other): pass
def __eq__(self, other): pass
- self.assertEqual(len(w), 2)
- self.assertWarning(None, w[:1],
+ self.assertEqual(len(w.warnings), 2)
+ self.assertWarning(None, w.warnings[0],
"Overriding __cmp__ blocks inheritance of __hash__ in 3.x")
self.assertWarning(None, w,
"Overriding __eq__ blocks inheritance of __hash__ in 3.x")
- del w[:]
+ w.reset()
class NoWarningOnlyHash(DefinesAllThree):
def __hash__(self): pass
- self.assertEqual(len(w), 0)
+ self.assertEqual(len(w.warnings), 0)
class TestStdlibRemovals(unittest.TestCase):
"""Make sure the specified module, when imported, raises a
DeprecationWarning and specifies itself in the message."""
with nested(CleanImport(module_name), warnings.catch_warnings()):
+ # XXX: This is not quite enough for extension modules - those
+ # won't rerun their init code even with CleanImport.
+ # You can see this easily by running the whole test suite with -3
warnings.filterwarnings("error", ".+ removed",
DeprecationWarning, __name__)
try:
def dumbo(where, names, args): pass
for path_mod in ("ntpath", "macpath", "os2emxpath", "posixpath"):
mod = __import__(path_mod)
- with warnings.catch_warnings(record=True) as w:
+ reset_module_registry(mod)
+ with check_warnings() as w:
mod.walk("crashers", dumbo, None)
- self.assertEquals(str(w[-1].message), msg)
+ self.assertEquals(str(w.message), msg)
def test_commands_members(self):
import commands
+ # commands module tests may have already triggered this warning
+ reset_module_registry(commands)
members = {"mk2arg" : 2, "mkarg" : 1, "getstatus" : 1}
for name, arg_count in members.items():
with warnings.catch_warnings():
def test_reduce_move(self):
from operator import add
+ # reduce tests may have already triggered this warning
+ reset_module_registry(unittest)
with warnings.catch_warnings():
warnings.filterwarnings("error", "reduce")
self.assertRaises(DeprecationWarning, reduce, add, range(10))
def test_mutablestring_removal(self):
# UserString.MutableString has been removed in 3.0.
import UserString
+ # UserString tests may have already triggered this warning
+ reset_module_registry(UserString)
with warnings.catch_warnings():
warnings.filterwarnings("error", ".*MutableString",
DeprecationWarning)
def test_main():
- with warnings.catch_warnings():
+ with check_warnings():
warnings.simplefilter("always")
run_unittest(TestPy3KWarnings,
TestStdlibRemovals)
wmod = self.module
orig_filters = wmod.filters
orig_showwarning = wmod.showwarning
- with wmod.catch_warnings(record=True, module=wmod):
+ # Ensure both showwarning and filters are restored when recording
+ with wmod.catch_warnings(module=wmod, record=True):
wmod.filters = wmod.showwarning = object()
self.assert_(wmod.filters is orig_filters)
self.assert_(wmod.showwarning is orig_showwarning)
+ # Same test, but with recording disabled
with wmod.catch_warnings(module=wmod, record=False):
wmod.filters = wmod.showwarning = object()
self.assert_(wmod.filters is orig_filters)
def test_catch_warnings_recording(self):
wmod = self.module
+ # Ensure warnings are recorded when requested
with wmod.catch_warnings(module=wmod, record=True) as w:
self.assertEqual(w, [])
- self.assertRaises(AttributeError, getattr, w, 'message')
+ self.assert_(type(w) is list)
wmod.simplefilter("always")
wmod.warn("foo")
self.assertEqual(str(w[-1].message), "foo")
self.assertEqual(str(w[1].message), "bar")
del w[:]
self.assertEqual(w, [])
+ # Ensure warnings are not recorded when not requested
orig_showwarning = wmod.showwarning
with wmod.catch_warnings(module=wmod, record=False) as w:
self.assert_(w is None)
self.assert_(wmod.showwarning is orig_showwarning)
+ def test_catch_warnings_reentry_guard(self):
+ wmod = self.module
+ # Ensure catch_warnings is protected against incorrect usage
+ x = wmod.catch_warnings(module=wmod, record=True)
+ self.assertRaises(RuntimeError, x.__exit__)
+ with x:
+ self.assertRaises(RuntimeError, x.__enter__)
+ # Same test, but with recording disabled
+ x = wmod.catch_warnings(module=wmod, record=False)
+ self.assertRaises(RuntimeError, x.__exit__)
+ with x:
+ self.assertRaises(RuntimeError, x.__enter__)
+
+ def test_catch_warnings_defaults(self):
+ wmod = self.module
+ orig_filters = wmod.filters
+ orig_showwarning = wmod.showwarning
+ # Ensure default behaviour is not to record warnings
+ with wmod.catch_warnings(module=wmod) as w:
+ self.assert_(w is None)
+ self.assert_(wmod.showwarning is orig_showwarning)
+ self.assert_(wmod.filters is not orig_filters)
+ self.assert_(wmod.filters is orig_filters)
+ if wmod is sys.modules['warnings']:
+ # Ensure the default module is this one
+ with wmod.catch_warnings() as w:
+ self.assert_(w is None)
+ self.assert_(wmod.showwarning is orig_showwarning)
+ self.assert_(wmod.filters is not orig_filters)
+ self.assert_(wmod.filters is orig_filters)
+
+ def test_check_warnings(self):
+ # Explicit tests for the test_support convenience wrapper
+ wmod = self.module
+ if wmod is sys.modules['warnings']:
+ with test_support.check_warnings() as w:
+ self.assertEqual(w.warnings, [])
+ wmod.simplefilter("always")
+ wmod.warn("foo")
+ self.assertEqual(str(w.message), "foo")
+ wmod.warn("bar")
+ self.assertEqual(str(w.message), "bar")
+ self.assertEqual(str(w.warnings[0].message), "foo")
+ self.assertEqual(str(w.warnings[1].message), "bar")
+ w.reset()
+ self.assertEqual(w.warnings, [])
+
+
+
class CCatchWarningTests(CatchWarningTests):
module = c_warnings
projects / python / commitdiff