1 import unittest 2 import sys 3 from test.test_support import check_py3k_warnings, CleanImport, run_unittest 4 import warnings 5 6 if not sys.py3kwarning: 7 raise unittest.SkipTest('%s must be run with the -3 flag' % __name__) 8 9 try: 10 from test.test_support import __warningregistry__ as _registry 11 except ImportError: 12 def check_deprecated_module(module_name): 13 return False 14 else: 15 past_warnings = _registry.keys() 16 del _registry 17 def check_deprecated_module(module_name): 18 """Lookup the past warnings for module already loaded using 19 test_support.import_module(..., deprecated=True) 20 """ 21 return any(module_name in msg and ' removed' in msg 22 and issubclass(cls, DeprecationWarning) 23 and (' module' in msg or ' package' in msg) 24 for (msg, cls, line) in past_warnings) 25 26 def reset_module_registry(module): 27 try: 28 registry = module.__warningregistry__ 29 except AttributeError: 30 pass 31 else: 32 registry.clear() 33 34 class TestPy3KWarnings(unittest.TestCase): 35 36 def assertWarning(self, _, warning, expected_message): 37 self.assertEqual(str(warning.message), expected_message) 38 39 def assertNoWarning(self, _, recorder): 40 self.assertEqual(len(recorder.warnings), 0) 41 42 def test_backquote(self): 43 expected = 'backquote not supported in 3.x; use repr()' 44 with check_py3k_warnings((expected, SyntaxWarning)): 45 exec "`2`" in {} 46 47 def test_paren_arg_names(self): 48 expected = 'parenthesized argument names are invalid in 3.x' 49 def check(s): 50 with check_py3k_warnings((expected, SyntaxWarning)): 51 exec s in {} 52 check("def f((x)): pass") 53 check("def f((((x))), (y)): pass") 54 check("def f((x), (((y))), m=32): pass") 55 # Something like def f((a, (b))): pass will raise the tuple 56 # unpacking warning. 57 58 def test_forbidden_names(self): 59 # So we don't screw up our globals 60 def safe_exec(expr): 61 def f(**kwargs): pass 62 exec expr in {'f' : f} 63 64 tests = [("True", "assignment to True or False is forbidden in 3.x"), 65 ("False", "assignment to True or False is forbidden in 3.x"), 66 ("nonlocal", "nonlocal is a keyword in 3.x")] 67 with check_py3k_warnings(('', SyntaxWarning)) as w: 68 for keyword, expected in tests: 69 safe_exec("{0} = False".format(keyword)) 70 self.assertWarning(None, w, expected) 71 w.reset() 72 try: 73 safe_exec("obj.{0} = True".format(keyword)) 74 except NameError: 75 pass 76 self.assertWarning(None, w, expected) 77 w.reset() 78 safe_exec("def {0}(): pass".format(keyword)) 79 self.assertWarning(None, w, expected) 80 w.reset() 81 safe_exec("class {0}: pass".format(keyword)) 82 self.assertWarning(None, w, expected) 83 w.reset() 84 safe_exec("def f({0}=43): pass".format(keyword)) 85 self.assertWarning(None, w, expected) 86 w.reset() 87 88 89 def test_type_inequality_comparisons(self): 90 expected = 'type inequality comparisons not supported in 3.x' 91 with check_py3k_warnings() as w: 92 self.assertWarning(int < str, w, expected) 93 w.reset() 94 self.assertWarning(type < object, w, expected) 95 96 def test_object_inequality_comparisons(self): 97 expected = 'comparing unequal types not supported in 3.x' 98 with check_py3k_warnings() as w: 99 self.assertWarning(str < [], w, expected) 100 w.reset() 101 self.assertWarning(object() < (1, 2), w, expected) 102 103 def test_dict_inequality_comparisons(self): 104 expected = 'dict inequality comparisons not supported in 3.x' 105 with check_py3k_warnings() as w: 106 self.assertWarning({} < {2:3}, w, expected) 107 w.reset() 108 self.assertWarning({} <= {}, w, expected) 109 w.reset() 110 self.assertWarning({} > {2:3}, w, expected) 111 w.reset() 112 self.assertWarning({2:3} >= {}, w, expected) 113 114 def test_cell_inequality_comparisons(self): 115 expected = 'cell comparisons not supported in 3.x' 116 def f(x): 117 def g(): 118 return x 119 return g 120 cell0, = f(0).func_closure 121 cell1, = f(1).func_closure 122 with check_py3k_warnings() as w: 123 self.assertWarning(cell0 == cell1, w, expected) 124 w.reset() 125 self.assertWarning(cell0 < cell1, w, expected) 126 127 def test_code_inequality_comparisons(self): 128 expected = 'code inequality comparisons not supported in 3.x' 129 def f(x): 130 pass 131 def g(x): 132 pass 133 with check_py3k_warnings() as w: 134 self.assertWarning(f.func_code < g.func_code, w, expected) 135 w.reset() 136 self.assertWarning(f.func_code <= g.func_code, w, expected) 137 w.reset() 138 self.assertWarning(f.func_code >= g.func_code, w, expected) 139 w.reset() 140 self.assertWarning(f.func_code > g.func_code, w, expected) 141 142 def test_builtin_function_or_method_comparisons(self): 143 expected = ('builtin_function_or_method ' 144 'order comparisons not supported in 3.x') 145 func = eval 146 meth = {}.get 147 with check_py3k_warnings() as w: 148 self.assertWarning(func < meth, w, expected) 149 w.reset() 150 self.assertWarning(func > meth, w, expected) 151 w.reset() 152 self.assertWarning(meth <= func, w, expected) 153 w.reset() 154 self.assertWarning(meth >= func, w, expected) 155 w.reset() 156 self.assertNoWarning(meth == func, w) 157 self.assertNoWarning(meth != func, w) 158 lam = lambda x: x 159 self.assertNoWarning(lam == func, w) 160 self.assertNoWarning(lam != func, w) 161 162 def test_frame_attributes(self): 163 template = "%s has been removed in 3.x" 164 f = sys._getframe(0) 165 for attr in ("f_exc_traceback", "f_exc_value", "f_exc_type"): 166 expected = template % attr 167 with check_py3k_warnings() as w: 168 self.assertWarning(getattr(f, attr), w, expected) 169 w.reset() 170 self.assertWarning(setattr(f, attr, None), w, expected) 171 172 def test_sort_cmp_arg(self): 173 expected = "the cmp argument is not supported in 3.x" 174 lst = range(5) 175 cmp = lambda x,y: -1 176 177 with check_py3k_warnings() as w: 178 self.assertWarning(lst.sort(cmp=cmp), w, expected) 179 w.reset() 180 self.assertWarning(sorted(lst, cmp=cmp), w, expected) 181 w.reset() 182 self.assertWarning(lst.sort(cmp), w, expected) 183 w.reset() 184 self.assertWarning(sorted(lst, cmp), w, expected) 185 186 def test_sys_exc_clear(self): 187 expected = 'sys.exc_clear() not supported in 3.x; use except clauses' 188 with check_py3k_warnings() as w: 189 self.assertWarning(sys.exc_clear(), w, expected) 190 191 def test_methods_members(self): 192 expected = '__members__ and __methods__ not supported in 3.x' 193 class C: 194 __methods__ = ['a'] 195 __members__ = ['b'] 196 c = C() 197 with check_py3k_warnings() as w: 198 self.assertWarning(dir(c), w, expected) 199 200 def test_softspace(self): 201 expected = 'file.softspace not supported in 3.x' 202 with file(__file__) as f: 203 with check_py3k_warnings() as w: 204 self.assertWarning(f.softspace, w, expected) 205 def set(): 206 f.softspace = 0 207 with check_py3k_warnings() as w: 208 self.assertWarning(set(), w, expected) 209 210 def test_slice_methods(self): 211 class Spam(object): 212 def __getslice__(self, i, j): pass 213 def __setslice__(self, i, j, what): pass 214 def __delslice__(self, i, j): pass 215 class Egg: 216 def __getslice__(self, i, h): pass 217 def __setslice__(self, i, j, what): pass 218 def __delslice__(self, i, j): pass 219 220 expected = "in 3.x, __{0}slice__ has been removed; use __{0}item__" 221 222 for obj in (Spam(), Egg()): 223 with check_py3k_warnings() as w: 224 self.assertWarning(obj[1:2], w, expected.format('get')) 225 w.reset() 226 del obj[3:4] 227 self.assertWarning(None, w, expected.format('del')) 228 w.reset() 229 obj[4:5] = "eggs" 230 self.assertWarning(None, w, expected.format('set')) 231 232 def test_tuple_parameter_unpacking(self): 233 expected = "tuple parameter unpacking has been removed in 3.x" 234 with check_py3k_warnings((expected, SyntaxWarning)): 235 exec "def f((a, b)): pass" 236 237 def test_buffer(self): 238 expected = 'buffer() not supported in 3.x' 239 with check_py3k_warnings() as w: 240 self.assertWarning(buffer('a'), w, expected) 241 242 def test_file_xreadlines(self): 243 expected = ("f.xreadlines() not supported in 3.x, " 244 "try 'for line in f' instead") 245 with file(__file__) as f: 246 with check_py3k_warnings() as w: 247 self.assertWarning(f.xreadlines(), w, expected) 248 249 def test_hash_inheritance(self): 250 with check_py3k_warnings() as w: 251 # With object as the base class 252 class WarnOnlyCmp(object): 253 def __cmp__(self, other): pass 254 self.assertEqual(len(w.warnings), 0) 255 w.reset() 256 class WarnOnlyEq(object): 257 def __eq__(self, other): pass 258 self.assertEqual(len(w.warnings), 1) 259 self.assertWarning(None, w, 260 "Overriding __eq__ blocks inheritance of __hash__ in 3.x") 261 w.reset() 262 class WarnCmpAndEq(object): 263 def __cmp__(self, other): pass 264 def __eq__(self, other): pass 265 self.assertEqual(len(w.warnings), 1) 266 self.assertWarning(None, w, 267 "Overriding __eq__ blocks inheritance of __hash__ in 3.x") 268 w.reset() 269 class NoWarningOnlyHash(object): 270 def __hash__(self): pass 271 self.assertEqual(len(w.warnings), 0) 272 # With an intermediate class in the heirarchy 273 class DefinesAllThree(object): 274 def __cmp__(self, other): pass 275 def __eq__(self, other): pass 276 def __hash__(self): pass 277 class WarnOnlyCmp(DefinesAllThree): 278 def __cmp__(self, other): pass 279 self.assertEqual(len(w.warnings), 0) 280 w.reset() 281 class WarnOnlyEq(DefinesAllThree): 282 def __eq__(self, other): pass 283 self.assertEqual(len(w.warnings), 1) 284 self.assertWarning(None, w, 285 "Overriding __eq__ blocks inheritance of __hash__ in 3.x") 286 w.reset() 287 class WarnCmpAndEq(DefinesAllThree): 288 def __cmp__(self, other): pass 289 def __eq__(self, other): pass 290 self.assertEqual(len(w.warnings), 1) 291 self.assertWarning(None, w, 292 "Overriding __eq__ blocks inheritance of __hash__ in 3.x") 293 w.reset() 294 class NoWarningOnlyHash(DefinesAllThree): 295 def __hash__(self): pass 296 self.assertEqual(len(w.warnings), 0) 297 298 def test_operator(self): 299 from operator import isCallable, sequenceIncludes 300 301 callable_warn = ("operator.isCallable() is not supported in 3.x. " 302 "Use hasattr(obj, '__call__').") 303 seq_warn = ("operator.sequenceIncludes() is not supported " 304 "in 3.x. Use operator.contains().") 305 with check_py3k_warnings() as w: 306 self.assertWarning(isCallable(self), w, callable_warn) 307 w.reset() 308 self.assertWarning(sequenceIncludes(range(3), 2), w, seq_warn) 309 310 311 class TestStdlibRemovals(unittest.TestCase): 312 313 # test.testall not tested as it executes all unit tests as an 314 # import side-effect. 315 all_platforms = ('audiodev', 'imputil', 'mutex', 'user', 'new', 'rexec', 316 'Bastion', 'compiler', 'dircache', 'mimetools', 317 'fpformat', 'ihooks', 'mhlib', 'statvfs', 'htmllib', 318 'sgmllib', 'rfc822', 'sunaudio') 319 inclusive_platforms = {'irix' : ('pure', 'AL', 'al', 'CD', 'cd', 'cddb', 320 'cdplayer', 'CL', 'cl', 'DEVICE', 'GL', 321 'gl', 'ERRNO', 'FILE', 'FL', 'flp', 'fl', 322 'fm', 'GET', 'GLWS', 'imgfile', 'IN', 323 'IOCTL', 'jpeg', 'panel', 'panelparser', 324 'readcd', 'SV', 'torgb', 'WAIT'), 325 'darwin' : ('autoGIL', 'Carbon', 'OSATerminology', 326 'icglue', 'Nav', 327 # MacOS should (and does) give a Py3kWarning, but one of the 328 # earlier tests already imports the MacOS extension which causes 329 # this test to fail. Disabling the test for 'MacOS' avoids this 330 # spurious test failure. 331 #'MacOS', 332 'aepack', 333 'aetools', 'aetypes', 'applesingle', 334 'appletrawmain', 'appletrunner', 335 'argvemulator', 'bgenlocations', 336 'EasyDialogs', 'macerrors', 'macostools', 337 'findertools', 'FrameWork', 'ic', 338 'gensuitemodule', 'icopen', 'macresource', 339 'MiniAEFrame', 'pimp', 'PixMapWrapper', 340 'terminalcommand', 'videoreader', 341 '_builtinSuites', 'CodeWarrior', 342 'Explorer', 'Finder', 'Netscape', 343 'StdSuites', 'SystemEvents', 'Terminal', 344 'cfmfile', 'bundlebuilder', 'buildtools', 345 'ColorPicker', 'Audio_mac'), 346 'sunos5' : ('sunaudiodev', 'SUNAUDIODEV'), 347 } 348 optional_modules = ('bsddb185', 'Canvas', 'dl', 'linuxaudiodev', 'imageop', 349 'sv', 'bsddb', 'dbhash') 350 351 def check_removal(self, module_name, optional=False): 352 """Make sure the specified module, when imported, raises a 353 DeprecationWarning and specifies itself in the message.""" 354 with CleanImport(module_name), warnings.catch_warnings(): 355 warnings.filterwarnings("error", ".+ (module|package) .+ removed", 356 DeprecationWarning, __name__) 357 warnings.filterwarnings("error", ".+ removed .+ (module|package)", 358 DeprecationWarning, __name__) 359 try: 360 __import__(module_name, level=0) 361 except DeprecationWarning as exc: 362 self.assertIn(module_name, exc.args[0], 363 "%s warning didn't contain module name" 364 % module_name) 365 except ImportError: 366 if not optional: 367 self.fail("Non-optional module {0} raised an " 368 "ImportError.".format(module_name)) 369 else: 370 # For extension modules, check the __warningregistry__. 371 # They won't rerun their init code even with CleanImport. 372 if not check_deprecated_module(module_name): 373 self.fail("DeprecationWarning not raised for {0}" 374 .format(module_name)) 375 376 def test_platform_independent_removals(self): 377 # Make sure that the modules that are available on all platforms raise 378 # the proper DeprecationWarning. 379 for module_name in self.all_platforms: 380 self.check_removal(module_name) 381 382 def test_platform_specific_removals(self): 383 # Test the removal of platform-specific modules. 384 for module_name in self.inclusive_platforms.get(sys.platform, []): 385 self.check_removal(module_name, optional=True) 386 387 def test_optional_module_removals(self): 388 # Test the removal of modules that may or may not be built. 389 for module_name in self.optional_modules: 390 self.check_removal(module_name, optional=True) 391 392 def test_os_path_walk(self): 393 msg = "In 3.x, os.path.walk is removed in favor of os.walk." 394 def dumbo(where, names, args): pass 395 for path_mod in ("ntpath", "macpath", "os2emxpath", "posixpath"): 396 mod = __import__(path_mod) 397 reset_module_registry(mod) 398 with check_py3k_warnings() as w: 399 mod.walk("crashers", dumbo, None) 400 self.assertEqual(str(w.message), msg) 401 402 def test_reduce_move(self): 403 from operator import add 404 # reduce tests may have already triggered this warning 405 reset_module_registry(unittest.case) 406 with warnings.catch_warnings(): 407 warnings.filterwarnings("error", "reduce") 408 self.assertRaises(DeprecationWarning, reduce, add, range(10)) 409 410 def test_mutablestring_removal(self): 411 # UserString.MutableString has been removed in 3.0. 412 import UserString 413 # UserString tests may have already triggered this warning 414 reset_module_registry(UserString) 415 with warnings.catch_warnings(): 416 warnings.filterwarnings("error", ".*MutableString", 417 DeprecationWarning) 418 self.assertRaises(DeprecationWarning, UserString.MutableString) 419 420 421 def test_main(): 422 run_unittest(TestPy3KWarnings, 423 TestStdlibRemovals) 424 425 if __name__ == '__main__': 426 test_main() 427
