import unittest | |
import sys | |
from test.test_support import check_py3k_warnings, CleanImport, run_unittest | |
import warnings | |
if not sys.py3kwarning: | |
raise unittest.SkipTest('%s must be run with the -3 flag' % __name__) | |
try: | |
from test.test_support import __warningregistry__ as _registry | |
except ImportError: | |
def check_deprecated_module(module_name): | |
return False | |
else: | |
past_warnings = _registry.keys() | |
del _registry | |
def check_deprecated_module(module_name): | |
"""Lookup the past warnings for module already loaded using | |
test_support.import_module(..., deprecated=True) | |
""" | |
return any(module_name in msg and ' removed' in msg | |
and issubclass(cls, DeprecationWarning) | |
and (' module' in msg or ' package' in msg) | |
for (msg, cls, line) in past_warnings) | |
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.message), expected_message) | |
def assertNoWarning(self, _, recorder): | |
self.assertEqual(len(recorder.warnings), 0) | |
def test_backquote(self): | |
expected = 'backquote not supported in 3.x; use repr()' | |
with check_py3k_warnings((expected, SyntaxWarning)): | |
exec "`2`" in {} | |
def test_paren_arg_names(self): | |
expected = 'parenthesized argument names are invalid in 3.x' | |
def check(s): | |
with check_py3k_warnings((expected, SyntaxWarning)): | |
exec s in {} | |
check("def f((x)): pass") | |
check("def f((((x))), (y)): pass") | |
check("def f((x), (((y))), m=32): pass") | |
# Something like def f((a, (b))): pass will raise the tuple | |
# unpacking warning. | |
def test_forbidden_names(self): | |
# So we don't screw up our globals | |
def safe_exec(expr): | |
def f(**kwargs): pass | |
exec expr in {'f' : f} | |
tests = [("True", "assignment to True or False is forbidden in 3.x"), | |
("False", "assignment to True or False is forbidden in 3.x"), | |
("nonlocal", "nonlocal is a keyword in 3.x")] | |
with check_py3k_warnings(('', SyntaxWarning)) as w: | |
for keyword, expected in tests: | |
safe_exec("{0} = False".format(keyword)) | |
self.assertWarning(None, w, expected) | |
w.reset() | |
try: | |
safe_exec("obj.{0} = True".format(keyword)) | |
except NameError: | |
pass | |
self.assertWarning(None, w, expected) | |
w.reset() | |
safe_exec("def {0}(): pass".format(keyword)) | |
self.assertWarning(None, w, expected) | |
w.reset() | |
safe_exec("class {0}: pass".format(keyword)) | |
self.assertWarning(None, w, expected) | |
w.reset() | |
safe_exec("def f({0}=43): pass".format(keyword)) | |
self.assertWarning(None, w, expected) | |
w.reset() | |
def test_type_inequality_comparisons(self): | |
expected = 'type inequality comparisons not supported in 3.x' | |
with check_py3k_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 check_py3k_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 check_py3k_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): | |
expected = 'cell comparisons not supported in 3.x' | |
def f(x): | |
def g(): | |
return x | |
return g | |
cell0, = f(0).func_closure | |
cell1, = f(1).func_closure | |
with check_py3k_warnings() as w: | |
self.assertWarning(cell0 == cell1, w, expected) | |
w.reset() | |
self.assertWarning(cell0 < cell1, w, expected) | |
def test_code_inequality_comparisons(self): | |
expected = 'code inequality comparisons not supported in 3.x' | |
def f(x): | |
pass | |
def g(x): | |
pass | |
with check_py3k_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): | |
expected = ('builtin_function_or_method ' | |
'order comparisons not supported in 3.x') | |
func = eval | |
meth = {}.get | |
with check_py3k_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) | |
w.reset() | |
self.assertNoWarning(meth == func, w) | |
self.assertNoWarning(meth != func, w) | |
lam = lambda x: x | |
self.assertNoWarning(lam == func, w) | |
self.assertNoWarning(lam != func, w) | |
def test_frame_attributes(self): | |
template = "%s has been removed in 3.x" | |
f = sys._getframe(0) | |
for attr in ("f_exc_traceback", "f_exc_value", "f_exc_type"): | |
expected = template % attr | |
with check_py3k_warnings() as w: | |
self.assertWarning(getattr(f, attr), w, expected) | |
w.reset() | |
self.assertWarning(setattr(f, attr, None), w, expected) | |
def test_sort_cmp_arg(self): | |
expected = "the cmp argument is not supported in 3.x" | |
lst = range(5) | |
cmp = lambda x,y: -1 | |
with check_py3k_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 check_py3k_warnings() as w: | |
self.assertWarning(sys.exc_clear(), w, expected) | |
def test_methods_members(self): | |
expected = '__members__ and __methods__ not supported in 3.x' | |
class C: | |
__methods__ = ['a'] | |
__members__ = ['b'] | |
c = C() | |
with check_py3k_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 check_py3k_warnings() as w: | |
self.assertWarning(f.softspace, w, expected) | |
def set(): | |
f.softspace = 0 | |
with check_py3k_warnings() as w: | |
self.assertWarning(set(), w, expected) | |
def test_slice_methods(self): | |
class Spam(object): | |
def __getslice__(self, i, j): pass | |
def __setslice__(self, i, j, what): pass | |
def __delslice__(self, i, j): pass | |
class Egg: | |
def __getslice__(self, i, h): pass | |
def __setslice__(self, i, j, what): pass | |
def __delslice__(self, i, j): pass | |
expected = "in 3.x, __{0}slice__ has been removed; use __{0}item__" | |
for obj in (Spam(), Egg()): | |
with check_py3k_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 check_py3k_warnings((expected, SyntaxWarning)): | |
exec "def f((a, b)): pass" | |
def test_buffer(self): | |
expected = 'buffer() not supported in 3.x' | |
with check_py3k_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 check_py3k_warnings() as w: | |
self.assertWarning(f.xreadlines(), w, expected) | |
def test_hash_inheritance(self): | |
with check_py3k_warnings() as w: | |
# With object as the base class | |
class WarnOnlyCmp(object): | |
def __cmp__(self, other): pass | |
self.assertEqual(len(w.warnings), 0) | |
w.reset() | |
class WarnOnlyEq(object): | |
def __eq__(self, other): pass | |
self.assertEqual(len(w.warnings), 1) | |
self.assertWarning(None, w, | |
"Overriding __eq__ blocks inheritance of __hash__ in 3.x") | |
w.reset() | |
class WarnCmpAndEq(object): | |
def __cmp__(self, other): pass | |
def __eq__(self, other): pass | |
self.assertEqual(len(w.warnings), 1) | |
self.assertWarning(None, w, | |
"Overriding __eq__ blocks inheritance of __hash__ in 3.x") | |
w.reset() | |
class NoWarningOnlyHash(object): | |
def __hash__(self): pass | |
self.assertEqual(len(w.warnings), 0) | |
# With an intermediate class in the heirarchy | |
class DefinesAllThree(object): | |
def __cmp__(self, other): pass | |
def __eq__(self, other): pass | |
def __hash__(self): pass | |
class WarnOnlyCmp(DefinesAllThree): | |
def __cmp__(self, other): pass | |
self.assertEqual(len(w.warnings), 0) | |
w.reset() | |
class WarnOnlyEq(DefinesAllThree): | |
def __eq__(self, other): pass | |
self.assertEqual(len(w.warnings), 1) | |
self.assertWarning(None, w, | |
"Overriding __eq__ blocks inheritance of __hash__ in 3.x") | |
w.reset() | |
class WarnCmpAndEq(DefinesAllThree): | |
def __cmp__(self, other): pass | |
def __eq__(self, other): pass | |
self.assertEqual(len(w.warnings), 1) | |
self.assertWarning(None, w, | |
"Overriding __eq__ blocks inheritance of __hash__ in 3.x") | |
w.reset() | |
class NoWarningOnlyHash(DefinesAllThree): | |
def __hash__(self): pass | |
self.assertEqual(len(w.warnings), 0) | |
def test_operator(self): | |
from operator import isCallable, sequenceIncludes | |
callable_warn = ("operator.isCallable() is not supported in 3.x. " | |
"Use hasattr(obj, '__call__').") | |
seq_warn = ("operator.sequenceIncludes() is not supported " | |
"in 3.x. Use operator.contains().") | |
with check_py3k_warnings() as w: | |
self.assertWarning(isCallable(self), w, callable_warn) | |
w.reset() | |
self.assertWarning(sequenceIncludes(range(3), 2), w, seq_warn) | |
class TestStdlibRemovals(unittest.TestCase): | |
# test.testall not tested as it executes all unit tests as an | |
# import side-effect. | |
all_platforms = ('audiodev', 'imputil', 'mutex', 'user', 'new', 'rexec', | |
'Bastion', 'compiler', 'dircache', 'mimetools', | |
'fpformat', 'ihooks', 'mhlib', 'statvfs', 'htmllib', | |
'sgmllib', 'rfc822', 'sunaudio') | |
inclusive_platforms = {'irix' : ('pure', 'AL', 'al', 'CD', 'cd', 'cddb', | |
'cdplayer', 'CL', 'cl', 'DEVICE', 'GL', | |
'gl', 'ERRNO', 'FILE', 'FL', 'flp', 'fl', | |
'fm', 'GET', 'GLWS', 'imgfile', 'IN', | |
'IOCTL', 'jpeg', 'panel', 'panelparser', | |
'readcd', 'SV', 'torgb', 'WAIT'), | |
'darwin' : ('autoGIL', 'Carbon', 'OSATerminology', | |
'icglue', 'Nav', | |
# MacOS should (and does) give a Py3kWarning, but one of the | |
# earlier tests already imports the MacOS extension which causes | |
# this test to fail. Disabling the test for 'MacOS' avoids this | |
# spurious test failure. | |
#'MacOS', | |
'aepack', | |
'aetools', 'aetypes', 'applesingle', | |
'appletrawmain', 'appletrunner', | |
'argvemulator', 'bgenlocations', | |
'EasyDialogs', 'macerrors', 'macostools', | |
'findertools', 'FrameWork', 'ic', | |
'gensuitemodule', 'icopen', 'macresource', | |
'MiniAEFrame', 'pimp', 'PixMapWrapper', | |
'terminalcommand', 'videoreader', | |
'_builtinSuites', 'CodeWarrior', | |
'Explorer', 'Finder', 'Netscape', | |
'StdSuites', 'SystemEvents', 'Terminal', | |
'cfmfile', 'bundlebuilder', 'buildtools', | |
'ColorPicker', 'Audio_mac'), | |
'sunos5' : ('sunaudiodev', 'SUNAUDIODEV'), | |
} | |
optional_modules = ('bsddb185', 'Canvas', 'dl', 'linuxaudiodev', 'imageop', | |
'sv', 'bsddb', 'dbhash') | |
def check_removal(self, module_name, optional=False): | |
"""Make sure the specified module, when imported, raises a | |
DeprecationWarning and specifies itself in the message.""" | |
with CleanImport(module_name), warnings.catch_warnings(): | |
warnings.filterwarnings("error", ".+ (module|package) .+ removed", | |
DeprecationWarning, __name__) | |
warnings.filterwarnings("error", ".+ removed .+ (module|package)", | |
DeprecationWarning, __name__) | |
try: | |
__import__(module_name, level=0) | |
except DeprecationWarning as exc: | |
self.assertIn(module_name, exc.args[0], | |
"%s warning didn't contain module name" | |
% module_name) | |
except ImportError: | |
if not optional: | |
self.fail("Non-optional module {0} raised an " | |
"ImportError.".format(module_name)) | |
else: | |
# For extension modules, check the __warningregistry__. | |
# They won't rerun their init code even with CleanImport. | |
if not check_deprecated_module(module_name): | |
self.fail("DeprecationWarning not raised for {0}" | |
.format(module_name)) | |
def test_platform_independent_removals(self): | |
# Make sure that the modules that are available on all platforms raise | |
# the proper DeprecationWarning. | |
for module_name in self.all_platforms: | |
self.check_removal(module_name) | |
def test_platform_specific_removals(self): | |
# Test the removal of platform-specific modules. | |
for module_name in self.inclusive_platforms.get(sys.platform, []): | |
self.check_removal(module_name, optional=True) | |
def test_optional_module_removals(self): | |
# Test the removal of modules that may or may not be built. | |
for module_name in self.optional_modules: | |
self.check_removal(module_name, optional=True) | |
def test_os_path_walk(self): | |
msg = "In 3.x, os.path.walk is removed in favor of os.walk." | |
def dumbo(where, names, args): pass | |
for path_mod in ("ntpath", "macpath", "os2emxpath", "posixpath"): | |
mod = __import__(path_mod) | |
reset_module_registry(mod) | |
with check_py3k_warnings() as w: | |
mod.walk("crashers", dumbo, None) | |
self.assertEqual(str(w.message), msg) | |
def test_reduce_move(self): | |
from operator import add | |
# reduce tests may have already triggered this warning | |
reset_module_registry(unittest.case) | |
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) | |
self.assertRaises(DeprecationWarning, UserString.MutableString) | |
def test_main(): | |
run_unittest(TestPy3KWarnings, | |
TestStdlibRemovals) | |
if __name__ == '__main__': | |
test_main() |