Index: Lib/test/test_urllib2_localnet.py =================================================================== --- Lib/test/test_urllib2_localnet.py (revision 77350) +++ Lib/test/test_urllib2_localnet.py (working copy) @@ -1,6 +1,5 @@ #!/usr/bin/env python -import mimetools import threading import urlparse import urllib2 @@ -8,6 +7,7 @@ import unittest import hashlib from test import test_support +mimetools = test_support.import_module('mimetools', deprecated=True) # Loopback http server infrastructure @@ -154,13 +154,13 @@ if len(self._users) == 0: return True - if not request_handler.headers.has_key('Proxy-Authorization'): + if 'Proxy-Authorization' not in request_handler.headers: return self._return_auth_challenge(request_handler) else: auth_dict = self._create_auth_dict( request_handler.headers['Proxy-Authorization'] ) - if self._users.has_key(auth_dict["username"]): + if auth_dict["username"] in self._users: password = self._users[ auth_dict["username"] ] else: return self._return_auth_challenge(request_handler) Index: Lib/test/test_optparse.py =================================================================== --- Lib/test/test_optparse.py (revision 77350) +++ Lib/test/test_optparse.py (working copy) @@ -26,12 +26,6 @@ from optparse import _match_abbrev from optparse import _parse_num -# Do the right thing with boolean values for all known Python versions. -try: - True, False -except NameError: - (True, False) = (1, 0) - retype = type(re.compile('')) class InterceptedError(Exception): Index: Lib/test/regrtest.py =================================================================== --- Lib/test/regrtest.py (revision 77350) +++ Lib/test/regrtest.py (working copy) @@ -150,7 +150,6 @@ import cStringIO import getopt import itertools -import json import os import random import re @@ -160,15 +159,13 @@ import warnings import unittest -# I see no other way to suppress these warnings; -# putting them in test_grammar.py has no effect: -warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning, - ".*test.test_grammar$") -if sys.maxint > 0x7fffffff: - # Also suppress them in , because for 64-bit platforms, - # that's where test_grammar.py hides them. - warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning, - "") +with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "tuple parameter unpacking " + "has been removed", SyntaxWarning) + warnings.filterwarnings("ignore", "assignment to True or False " + "is forbidden", SyntaxWarning) + import json # Ignore ImportWarnings that only occur in the source tree, # (because of modules with the same name as source-directories in Modules/) Index: Lib/test/test_repr.py =================================================================== --- Lib/test/test_repr.py (revision 77350) +++ Lib/test/test_repr.py (working copy) @@ -8,7 +8,7 @@ import shutil import unittest -from test.test_support import run_unittest +from test.test_support import run_unittest, check_warnings from repr import repr as r # Don't shadow builtin repr from repr import Repr @@ -174,7 +174,9 @@ def test_buffer(self): # XXX doesn't test buffers with no b_base or read-write buffers (see # bufferobject.c). The test is fairly incomplete too. Sigh. - x = buffer('foo') + # Silence the Py3k warning + with check_warnings(): + x = buffer('foo') self.assertTrue(repr(x).startswith('>> def sorted(seq): - ... seq.sort() + ... seq.sort(key=str) ... return seq >>> print sorted(a.keys()) [1, 2] Index: Lib/test/test_io.py =================================================================== --- Lib/test/test_io.py (revision 77350) +++ Lib/test/test_io.py (working copy) @@ -381,11 +381,11 @@ f = None try: with self.open(support.TESTFN, "wb", bufsize) as f: - 1/0 + 1 // 0 except ZeroDivisionError: self.assertEqual(f.closed, True) else: - self.fail("1/0 didn't raise an exception") + self.fail("1 // 0 didn't raise an exception") # issue 5008 def test_append_mode_tell(self): Index: Lib/test/test_ctypes.py =================================================================== --- Lib/test/test_ctypes.py (revision 77350) +++ Lib/test/test_ctypes.py (working copy) @@ -4,12 +4,19 @@ #Skip tests if _ctypes module does not exist import_module('_ctypes') +import warnings import ctypes.test def test_main(): skipped, testcases = ctypes.test.get_tests(ctypes.test, "test_*.py", verbosity=0) suites = [unittest.makeSuite(t) for t in testcases] - run_unittest(unittest.TestSuite(suites)) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "buffer.. not supported", + DeprecationWarning) + warnings.filterwarnings("ignore", "classic long division", + DeprecationWarning) + run_unittest(unittest.TestSuite(suites)) if __name__ == "__main__": test_main() Index: Lib/test/test_importhooks.py =================================================================== --- Lib/test/test_importhooks.py (revision 77350) +++ Lib/test/test_importhooks.py (working copy) @@ -180,7 +180,7 @@ self.assertFalse(hasattr(reloadmodule,'reloaded')) TestImporter.modules['reloadmodule'] = (False, reload_co) - reload(reloadmodule) + imp.reload(reloadmodule) self.assertTrue(hasattr(reloadmodule,'reloaded')) import hooktestpackage.oldabs @@ -247,9 +247,11 @@ for n in sys.modules.keys(): if n.startswith(parent): del sys.modules[n] - for mname in mnames: - m = __import__(mname, globals(), locals(), ["__dummy__"]) - m.__loader__ # to make sure we actually handled the import + # Silence Py3k warning + with test_support.check_warnings(): + for mname in mnames: + m = __import__(mname, globals(), locals(), ["__dummy__"]) + m.__loader__ # to make sure we actually handled the import def test_main(): Index: Lib/test/test_traceback.py =================================================================== --- Lib/test/test_traceback.py (revision 77350) +++ Lib/test/test_traceback.py (working copy) @@ -4,6 +4,7 @@ from StringIO import StringIO import sys import unittest +from imp import reload from test.test_support import run_unittest, is_jython, Error import traceback @@ -148,7 +149,7 @@ def test_format_exception_only_bad__str__(self): class X(Exception): def __str__(self): - 1/0 + 1 // 0 err = traceback.format_exception_only(X, X()) self.assertEqual(len(err), 1) str_value = '' % X.__name__ Index: Lib/test/test_dict.py =================================================================== --- Lib/test/test_dict.py (revision 77350) +++ Lib/test/test_dict.py (working copy) @@ -33,8 +33,12 @@ self.assertEqual(d.keys(), []) d = {'a': 1, 'b': 2} k = d.keys() - self.assertTrue(d.has_key('a')) - self.assertTrue(d.has_key('b')) + self.assertTrue('a' in d) + self.assertTrue('b' in d) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertTrue(d.has_key('a')) + self.assertTrue(d.has_key('b')) self.assertRaises(TypeError, d.keys, None) @@ -57,14 +61,16 @@ def test_has_key(self): d = {} - self.assertTrue(not d.has_key('a')) + self.assertTrue('a' not in d) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertTrue(not d.has_key('a')) + self.assertRaises(TypeError, d.has_key) d = {'a': 1, 'b': 2} k = d.keys() k.sort() self.assertEqual(k, ['a', 'b']) - self.assertRaises(TypeError, d.has_key) - def test_contains(self): d = {} self.assertTrue(not ('a' in d)) @@ -395,8 +401,6 @@ self.assertRaises(Exc, repr, d) def test_le(self): - self.assertTrue(not ({} < {})) - self.assertTrue(not ({1: 2} < {1L: 2L})) class Exc(Exception): pass @@ -408,12 +412,18 @@ d1 = {BadCmp(): 1} d2 = {1: 1} - try: - d1 < d2 - except Exc: - pass - else: - self.fail("< didn't raise Exc") + + # Silence Py3k warning + with test_support.check_warnings(): + self.assertTrue(not ({} < {})) + self.assertTrue(not ({1: 2} < {1L: 2L})) + + try: + d1 < d2 + except Exc: + pass + else: + self.fail("< didn't raise Exc") def test_missing(self): # Make sure dict doesn't have a __missing__ method @@ -501,7 +511,9 @@ 'd.pop(x2)', 'd.update({x2: 2})']: try: - exec stmt in locals() + # Silence Py3k warning + with test_support.check_warnings(): + exec stmt in locals() except CustomException: pass else: @@ -549,7 +561,7 @@ # Bug #3537: if an empty but presized dict with a size larger # than 7 was in the freelist, it triggered an assertion failure try: - d = {'a': 1/0, 'b': None, 'c': None, 'd': None, 'e': None, + d = {'a': 1 // 0, 'b': None, 'c': None, 'd': None, 'e': None, 'f': None, 'g': None, 'h': None} except ZeroDivisionError: pass Index: Lib/test/test_set.py =================================================================== --- Lib/test/test_set.py (revision 77350) +++ Lib/test/test_set.py (working copy) @@ -1218,15 +1218,16 @@ self.assertEqual(self.set != self.other, True) def test_ge_gt_le_lt(self): - self.assertRaises(TypeError, lambda: self.set < self.other) - self.assertRaises(TypeError, lambda: self.set <= self.other) - self.assertRaises(TypeError, lambda: self.set > self.other) - self.assertRaises(TypeError, lambda: self.set >= self.other) - - self.assertRaises(TypeError, lambda: self.other < self.set) - self.assertRaises(TypeError, lambda: self.other <= self.set) - self.assertRaises(TypeError, lambda: self.other > self.set) - self.assertRaises(TypeError, lambda: self.other >= self.set) + with test_support.check_warnings(): + self.assertRaises(TypeError, lambda: self.set < self.other) + self.assertRaises(TypeError, lambda: self.set <= self.other) + self.assertRaises(TypeError, lambda: self.set > self.other) + self.assertRaises(TypeError, lambda: self.set >= self.other) + + self.assertRaises(TypeError, lambda: self.other < self.set) + self.assertRaises(TypeError, lambda: self.other <= self.set) + self.assertRaises(TypeError, lambda: self.other > self.set) + self.assertRaises(TypeError, lambda: self.other >= self.set) def test_update_operator(self): try: @@ -1379,20 +1380,20 @@ def test_copy(self): dup = self.set.copy() - dup_list = list(dup); dup_list.sort() - set_list = list(self.set); set_list.sort() + dup_list = list(dup) + set_list = list(self.set) self.assertEqual(len(dup_list), len(set_list)) - for i in range(len(dup_list)): - self.assertTrue(dup_list[i] is set_list[i]) + for elt in dup_list: + self.assertTrue(elt in set_list) def test_deep_copy(self): dup = copy.deepcopy(self.set) ##print type(dup), repr(dup) - dup_list = list(dup); dup_list.sort() - set_list = list(self.set); set_list.sort() + dup_list = list(dup) + set_list = list(self.set) self.assertEqual(len(dup_list), len(set_list)) - for i in range(len(dup_list)): - self.assertEqual(dup_list[i], set_list[i]) + for elt in dup_list: + self.assertTrue(elt in set_list) #------------------------------------------------------------------------------ @@ -1552,7 +1553,7 @@ for cons in (set, frozenset): for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, S, L, R): - self.assertEqual(sorted(cons(g(s))), sorted(g(s))) + self.assertSameElements(cons(g(s)), g(s)) self.assertRaises(TypeError, cons , X(s)) self.assertRaises(TypeError, cons , N(s)) self.assertRaises(ZeroDivisionError, cons , E(s)) @@ -1567,7 +1568,7 @@ if isinstance(expected, bool): self.assertEqual(actual, expected) else: - self.assertEqual(sorted(actual), sorted(expected)) + self.assertSameElements(actual, expected) self.assertRaises(TypeError, meth, X(s)) self.assertRaises(TypeError, meth, N(s)) self.assertRaises(ZeroDivisionError, meth, E(s)) @@ -1581,7 +1582,7 @@ t = s.copy() getattr(s, methname)(list(g(data))) getattr(t, methname)(g(data)) - self.assertEqual(sorted(s), sorted(t)) + self.assertSameElements(s, t) self.assertRaises(TypeError, getattr(set('january'), methname), X(data)) self.assertRaises(TypeError, getattr(set('january'), methname), N(data)) Index: Lib/test/test_descr.py =================================================================== --- Lib/test/test_descr.py (revision 77350) +++ Lib/test/test_descr.py (working copy) @@ -4598,9 +4598,19 @@ def test_main(): - # Run all local test cases, with PTypesLongInitTest first. - test_support.run_unittest(PTypesLongInitTest, OperatorsTest, - ClassPropertiesAndMethods, DictProxyTests) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "classic .+ division", + DeprecationWarning) + warnings.filterwarnings("ignore", "coerce.. not supported", + DeprecationWarning) + warnings.filterwarnings("ignore", "Overriding __cmp__ ", + DeprecationWarning) + warnings.filterwarnings("ignore", ".+slice__ has been removed", + DeprecationWarning) + # Run all local test cases, with PTypesLongInitTest first. + test_support.run_unittest(PTypesLongInitTest, OperatorsTest, + ClassPropertiesAndMethods, DictProxyTests) if __name__ == "__main__": test_main() Index: Lib/test/test_ssl.py =================================================================== --- Lib/test/test_ssl.py (revision 77350) +++ Lib/test/test_ssl.py (working copy) @@ -808,7 +808,7 @@ if test_support.verbose: sys.stdout.write(pprint.pformat(cert) + '\n') sys.stdout.write("Connection cipher is " + str(cipher) + '.\n') - if not cert.has_key('subject'): + if 'subject' not in cert: raise test_support.TestFailed( "No subject field in certificate: %s." % pprint.pformat(cert)) @@ -970,7 +970,9 @@ # now fetch the same data from the HTTPS server url = 'https://127.0.0.1:%d/%s' % ( server.port, os.path.split(CERTFILE)[1]) - f = urllib.urlopen(url) + # Silence Py3k warning + with test_support.check_warnings(): + f = urllib.urlopen(url) dlen = f.info().getheader("content-length") if dlen and (int(dlen) > 0): d2 = f.read(int(dlen)) Index: Lib/test/test_xmllib.py =================================================================== --- Lib/test/test_xmllib.py (revision 77350) +++ Lib/test/test_xmllib.py (working copy) @@ -15,13 +15,10 @@ nsdoc = "" -import warnings -warnings.filterwarnings("ignore", ".* xmllib .* obsolete.*", - DeprecationWarning, r'xmllib$') - from test import test_support import unittest -import xmllib +# Silence Py3k warning +xmllib = test_support.import_module('xmllib', deprecated=True) class XMLParserTestCase(unittest.TestCase): Index: Lib/test/test_opcodes.py =================================================================== --- Lib/test/test_opcodes.py (revision 77350) +++ Lib/test/test_opcodes.py (working copy) @@ -2,6 +2,7 @@ from test.test_support import run_unittest import unittest +import warnings class OpcodeTest(unittest.TestCase): @@ -9,7 +10,7 @@ n = 0 for i in range(10): n = n+i - try: 1/0 + try: 1 // 0 except NameError: pass except ZeroDivisionError: pass except TypeError: pass @@ -110,7 +111,14 @@ def test_main(): - run_unittest(OpcodeTest) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "exceptions must derive from " + "BaseException", DeprecationWarning) + warnings.filterwarnings("ignore", "catching classes that don't " + "inherit from BaseException is not allowed", + DeprecationWarning) + run_unittest(OpcodeTest) if __name__ == '__main__': test_main() Index: Lib/test/test_site.py =================================================================== --- Lib/test/test_site.py (revision 77350) +++ Lib/test/test_site.py (working copy) @@ -258,7 +258,7 @@ site.abs__file__() for module in (sys, os, __builtin__): try: - self.assertTrue(os.path.isabs(module.__file__), `module`) + self.assertTrue(os.path.isabs(module.__file__), repr(module)) except AttributeError: continue # We could try everything in sys.modules; however, when regrtest.py @@ -310,7 +310,7 @@ def test_sitecustomize_executed(self): # If sitecustomize is available, it should have been imported. - if not sys.modules.has_key("sitecustomize"): + if "sitecustomize" not in sys.modules: try: import sitecustomize except ImportError: Index: Lib/test/test_inspect.py =================================================================== --- Lib/test/test_inspect.py (revision 77350) +++ Lib/test/test_inspect.py (working copy) @@ -4,10 +4,11 @@ import inspect import datetime -from test.test_support import TESTFN, run_unittest +from test.test_support import TESTFN, run_unittest, check_warnings -from test import inspect_fodder as mod -from test import inspect_fodder2 as mod2 +with check_warnings(): + from test import inspect_fodder as mod + from test import inspect_fodder2 as mod2 # C module for test_findsource_binary import unicodedata @@ -29,7 +30,7 @@ import __builtin__ try: - 1/0 + 1 // 0 except: tb = sys.exc_traceback @@ -167,7 +168,7 @@ self.assertEqual(git.tr[1][1:], (modfile, 9, 'spam', [' eggs(b + d, c + f)\n'], 0)) self.assertEqual(git.tr[2][1:], (modfile, 18, 'eggs', - [' q = y / 0\n'], 0)) + [' q = y // 0\n'], 0)) def test_frame(self): args, varargs, varkw, locals = inspect.getargvalues(mod.fr) @@ -418,11 +419,13 @@ self.assertArgSpecEquals(A.m, ['self']) def test_getargspec_sublistofone(self): - def sublistOfOne((foo,)): return 1 - self.assertArgSpecEquals(sublistOfOne, [['foo']]) + # Silence Py3k warning + with check_warnings(): + exec 'def sublistOfOne((foo,)): return 1' + self.assertArgSpecEquals(sublistOfOne, [['foo']]) - def fakeSublistOfOne((foo)): return 1 - self.assertArgSpecEquals(fakeSublistOfOne, ['foo']) + exec 'def fakeSublistOfOne((foo)): return 1' + self.assertArgSpecEquals(fakeSublistOfOne, ['foo']) def test_classify_oldstyle(self): class A: Index: Lib/test/test_array.py =================================================================== --- Lib/test/test_array.py (revision 77350) +++ Lib/test/test_array.py (working copy) @@ -749,7 +749,9 @@ def test_buffer(self): a = array.array(self.typecode, self.example) - b = buffer(a) + # Silence Py3k warning + with test_support.check_warnings(): + b = buffer(a) self.assertEqual(b[0], a.tostring()[0]) def test_weakref(self): Index: Lib/test/test_complex_args.py =================================================================== --- Lib/test/test_complex_args.py (revision 77350) +++ Lib/test/test_complex_args.py (working copy) @@ -1,23 +1,31 @@ import unittest from test import test_support +import textwrap +import warnings class ComplexArgsTestCase(unittest.TestCase): def check(self, func, expected, *args): self.assertEqual(func(*args), expected) - # These functions are tested below as lambdas too. If you add a function test, - # also add a similar lambda test. + # These functions are tested below as lambdas too. If you add a + # function test, also add a similar lambda test. + + # Functions are wrapped in "exec" statements in order to + # silence Py3k warnings def test_func_parens_no_unpacking(self): + exec textwrap.dedent(""" def f(((((x))))): return x self.check(f, 1, 1) # Inner parens are elided, same as: f(x,) def f(((x)),): return x self.check(f, 2, 2) + """) def test_func_1(self): + exec textwrap.dedent(""" def f(((((x),)))): return x self.check(f, 3, (3,)) def f(((((x)),))): return x @@ -26,16 +34,22 @@ self.check(f, 5, (5,)) def f(((x),)): return x self.check(f, 6, (6,)) + """) def test_func_2(self): + exec textwrap.dedent(""" def f(((((x)),),)): return x self.check(f, 2, ((2,),)) + """) def test_func_3(self): + exec textwrap.dedent(""" def f((((((x)),),),)): return x self.check(f, 3, (((3,),),)) + """) def test_func_complex(self): + exec textwrap.dedent(""" def f((((((x)),),),), a, b, c): return x, a, b, c self.check(f, (3, 9, 8, 7), (((3,),),), 9, 8, 7) @@ -44,18 +58,22 @@ def f(a, b, c, ((((((x)),)),),)): return a, b, c, x self.check(f, (9, 8, 7, 3), 9, 8, 7, (((3,),),)) + """) # Duplicate the tests above, but for lambda. If you add a lambda test, # also add a similar function test above. def test_lambda_parens_no_unpacking(self): + exec textwrap.dedent(""" f = lambda (((((x))))): x self.check(f, 1, 1) # Inner parens are elided, same as: f(x,) f = lambda ((x)),: x self.check(f, 2, 2) + """) def test_lambda_1(self): + exec textwrap.dedent(""" f = lambda (((((x),)))): x self.check(f, 3, (3,)) f = lambda (((((x)),))): x @@ -64,16 +82,22 @@ self.check(f, 5, (5,)) f = lambda (((x),)): x self.check(f, 6, (6,)) + """) def test_lambda_2(self): + exec textwrap.dedent(""" f = lambda (((((x)),),)): x self.check(f, 2, ((2,),)) + """) def test_lambda_3(self): + exec textwrap.dedent(""" f = lambda ((((((x)),),),)): x self.check(f, 3, (((3,),),)) + """) def test_lambda_complex(self): + exec textwrap.dedent(""" f = lambda (((((x)),),),), a, b, c: (x, a, b, c) self.check(f, (3, 9, 8, 7), (((3,),),), 9, 8, 7) @@ -82,10 +106,17 @@ f = lambda a, b, c, ((((((x)),)),),): (a, b, c, x) self.check(f, (9, 8, 7, 3), 9, 8, 7, (((3,),),)) + """) def test_main(): - test_support.run_unittest(ComplexArgsTestCase) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "tuple parameter unpacking " + "has been removed", SyntaxWarning) + warnings.filterwarnings("ignore", "parenthesized argument names " + "are invalid", SyntaxWarning) + test_support.run_unittest(ComplexArgsTestCase) if __name__ == "__main__": test_main() Index: Lib/test/test_itertools.py =================================================================== --- Lib/test/test_itertools.py (revision 77350) +++ Lib/test/test_itertools.py (working copy) @@ -9,6 +9,7 @@ import random import copy import pickle +from functools import reduce maxsize = test_support.MAX_Py_ssize_t minsize = -maxsize-1 @@ -122,7 +123,7 @@ values = [5*x-12 for x in range(n)] for r in range(n+2): result = list(combinations(values, r)) - self.assertEqual(len(result), 0 if r>n else fact(n) / fact(r) / fact(n-r)) # right number of combs + self.assertEqual(len(result), 0 if r>n else fact(n) // fact(r) // fact(n-r)) # right number of combs self.assertEqual(len(result), len(set(result))) # no repeats self.assertEqual(result, sorted(result)) # lexicographic order for c in result: @@ -178,7 +179,7 @@ def numcombs(n, r): if not n: return 0 if r else 1 - return fact(n+r-1) / fact(r)/ fact(n-1) + return fact(n+r-1) // fact(r) // fact(n-1) for n in range(7): values = [5*x-12 for x in range(n)] @@ -257,7 +258,7 @@ values = [5*x-12 for x in range(n)] for r in range(n+2): result = list(permutations(values, r)) - self.assertEqual(len(result), 0 if r>n else fact(n) / fact(n-r)) # right number of perms + self.assertEqual(len(result), 0 if r>n else fact(n) // fact(n-r)) # right number of perms self.assertEqual(len(result), len(set(result))) # no repeats self.assertEqual(result, sorted(result)) # lexicographic order for p in result: @@ -288,9 +289,9 @@ # Check size self.assertEquals(len(prod), n**r) - self.assertEquals(len(cwr), (fact(n+r-1) / fact(r)/ fact(n-1)) if n else (not r)) - self.assertEquals(len(perm), 0 if r>n else fact(n) / fact(n-r)) - self.assertEquals(len(comb), 0 if r>n else fact(n) / fact(r) / fact(n-r)) + self.assertEquals(len(cwr), (fact(n+r-1) // fact(r) // fact(n-1)) if n else (not r)) + self.assertEquals(len(perm), 0 if r>n else fact(n) // fact(n-r)) + self.assertEquals(len(comb), 0 if r>n else fact(n) // fact(r) // fact(n-r)) # Check lexicographic order without repeated tuples self.assertEquals(prod, sorted(set(prod))) @@ -543,7 +544,8 @@ [range(1000), range(0), range(3000,3050), range(1200), range(1500)], [range(1000), range(0), range(3000,3050), range(1200), range(1500), range(0)], ]: - target = map(None, *args) + target = [tuple([arg[i] if i < len(arg) else None for arg in args]) + for i in range(max(map(len, args)))] self.assertEqual(list(izip_longest(*args)), target) self.assertEqual(list(izip_longest(*args, **{})), target) target = [tuple((e is None and 'X' or e) for e in t) for t in target] # Replace None fills with 'X' @@ -555,7 +557,8 @@ self.assertEqual(list(izip_longest([])), zip([])) self.assertEqual(list(izip_longest('abcdef')), zip('abcdef')) - self.assertEqual(list(izip_longest('abc', 'defg', **{})), map(None, 'abc', 'defg')) # empty keyword dict + self.assertEqual(list(izip_longest('abc', 'defg', **{})), + zip(list('abc') + [None], 'defg')) # empty keyword dict self.assertRaises(TypeError, izip_longest, 3) self.assertRaises(TypeError, izip_longest, range(3), 3) @@ -1431,7 +1434,7 @@ # is differencing with a range so that consecutive numbers all appear in # same group. >>> data = [ 1, 4,5,6, 10, 15,16,17,18, 22, 25,26,27,28] ->>> for k, g in groupby(enumerate(data), lambda (i,x):i-x): +>>> for k, g in groupby(enumerate(data), lambda t:t[0]-t[1]): ... print map(operator.itemgetter(1), g) ... [1] Index: Lib/test/test_socket.py =================================================================== --- Lib/test/test_socket.py (revision 77350) +++ Lib/test/test_socket.py (working copy) @@ -123,7 +123,7 @@ self.server_ready.wait() self.client_ready.set() self.clientSetUp() - if not callable(test_func): + if not hasattr(test_func, '__call__'): raise TypeError, "test_func must be a callable function" try: test_func() @@ -282,7 +282,7 @@ orig = sys.getrefcount(__name__) socket.getnameinfo(__name__,0) except TypeError: - if sys.getrefcount(__name__) <> orig: + if sys.getrefcount(__name__) != orig: self.fail("socket.getnameinfo loses a reference") def testInterpreterCrash(self): @@ -1234,7 +1234,9 @@ self.assertEqual(msg, MSG) def _testRecvInto(self): - buf = buffer(MSG) + # Silence Py3k warning + with test_support.check_warnings(): + buf = buffer(MSG) self.serv_conn.send(buf) def testRecvFromInto(self): @@ -1245,7 +1247,9 @@ self.assertEqual(msg, MSG) def _testRecvFromInto(self): - buf = buffer(MSG) + # Silence Py3k warning + with test_support.check_warnings(): + buf = buffer(MSG) self.serv_conn.send(buf) Index: Lib/test/infinite_reload.py =================================================================== --- Lib/test/infinite_reload.py (revision 77350) +++ Lib/test/infinite_reload.py (working copy) @@ -3,5 +3,6 @@ # reload()ing. This module is imported by test_import.py:test_infinite_reload # to make sure this doesn't happen any more. +import imp import infinite_reload -reload(infinite_reload) +imp.reload(infinite_reload) Index: Lib/test/test_transformer.py =================================================================== --- Lib/test/test_transformer.py (revision 77350) +++ Lib/test/test_transformer.py (working copy) @@ -1,5 +1,8 @@ import unittest from test import test_support + +# Silence Py3k warning +test_support.import_module('compiler', deprecated=True) from compiler import transformer, ast from compiler import compile Index: Lib/test/test_with.py =================================================================== --- Lib/test/test_with.py (revision 77350) +++ Lib/test/test_with.py (working copy) @@ -520,7 +520,7 @@ self.assertRaises(AssertionError, falseAsBool) def failAsBool(): - with cm(lambda: 1//0): + with cm(lambda: 1 // 0): self.fail("Should NOT see this") self.assertRaises(ZeroDivisionError, failAsBool) @@ -628,7 +628,7 @@ def __exit__(self, t, v, tb): return True try: with AfricanSwallow(): - 1/0 + 1 // 0 except ZeroDivisionError: self.fail("ZeroDivisionError should have been swallowed") @@ -638,7 +638,7 @@ def __exit__(self, t, v, tb): return False try: with EuropeanSwallow(): - 1/0 + 1 // 0 except ZeroDivisionError: pass else: Index: Lib/test/test_file.py =================================================================== --- Lib/test/test_file.py (revision 77350) +++ Lib/test/test_file.py (working copy) @@ -127,7 +127,7 @@ self.assertEquals(self.f.__exit__(None, None, None), None) # it must also return None if an exception was given try: - 1/0 + 1 // 0 except: self.assertEquals(self.f.__exit__(*sys.exc_info()), None) Index: Lib/test/test_threadsignals.py =================================================================== --- Lib/test/test_threadsignals.py (revision 77350) +++ Lib/test/test_threadsignals.py (working copy) @@ -14,7 +14,7 @@ signalled_all=thread.allocate_lock() -def registerSignals((for_usr1, for_usr2, for_alrm)): +def registerSignals(for_usr1, for_usr2, for_alrm): usr1 = signal.signal(signal.SIGUSR1, for_usr1) usr2 = signal.signal(signal.SIGUSR2, for_usr2) alrm = signal.signal(signal.SIGALRM, for_alrm) @@ -74,11 +74,11 @@ signal.SIGUSR2 : {'tripped': 0, 'tripped_by': 0 }, signal.SIGALRM : {'tripped': 0, 'tripped_by': 0 } } - oldsigs = registerSignals((handle_signals, handle_signals, handle_signals)) + oldsigs = registerSignals(handle_signals, handle_signals, handle_signals) try: run_unittest(ThreadSignals) finally: - registerSignals(oldsigs) + registerSignals(*oldsigs) if __name__ == '__main__': test_main() Index: Lib/test/test_pyclbr.py =================================================================== --- Lib/test/test_pyclbr.py (revision 77350) +++ Lib/test/test_pyclbr.py (working copy) @@ -2,7 +2,7 @@ Test cases for pyclbr.py Nick Mathewson ''' -from test.test_support import run_unittest +from test.test_support import run_unittest, import_module import sys from types import ClassType, FunctionType, MethodType, BuiltinFunctionType import pyclbr @@ -13,6 +13,8 @@ # This next line triggers an error on old versions of pyclbr. +# Silence Py3k warning +import_module('commands', deprecated=True) from commands import getstatus # Here we test the python class browser code. @@ -40,11 +42,11 @@ def assertHaskey(self, obj, key, ignore): - ''' succeed iff obj.has_key(key) or key in ignore. ''' + ''' succeed iff key in obj or key in ignore. ''' if key in ignore: return - if not obj.has_key(key): - print >>sys.stderr, "***",key - self.assertTrue(obj.has_key(key)) + if key not in obj: + print >>sys.stderr, "***", key + self.assertTrue(key in obj) def assertEqualsOrIgnored(self, a, b, ignore): ''' succeed iff a == b or a in ignore or b in ignore ''' @@ -149,7 +151,9 @@ def test_easy(self): self.checkModule('pyclbr') self.checkModule('doctest', ignore=("DocTestCase",)) - self.checkModule('rfc822') + # Silence Py3k warning + rfc822 = import_module('rfc822', deprecated=True) + self.checkModule('rfc822', rfc822) self.checkModule('difflib') def test_decorators(self): Index: Lib/test/test_heapq.py =================================================================== --- Lib/test/test_heapq.py (revision 77350) +++ Lib/test/test_heapq.py (working copy) @@ -356,7 +356,8 @@ for f in (self.module.nlargest, self.module.nsmallest): for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)): for g in (G, I, Ig, L, R): - self.assertEqual(f(2, g(s)), f(2,s)) + with test_support.check_warnings(): + self.assertEqual(f(2, g(s)), f(2,s)) self.assertEqual(f(2, S(s)), []) self.assertRaises(TypeError, f, 2, X(s)) self.assertRaises(TypeError, f, 2, N(s)) Index: Lib/test/test_StringIO.py =================================================================== --- Lib/test/test_StringIO.py (revision 77350) +++ Lib/test/test_StringIO.py (working copy) @@ -137,12 +137,10 @@ def test_main(): - test_support.run_unittest( - TestStringIO, - TestcStringIO, - TestBufferStringIO, - TestBuffercStringIO - ) + test_support.run_unittest(TestStringIO, TestcStringIO) + # Silence Py3k warning + with test_support.check_warnings(): + test_support.run_unittest(TestBufferStringIO, TestBuffercStringIO) if __name__ == '__main__': test_main() Index: Lib/test/test_long.py =================================================================== --- Lib/test/test_long.py (revision 77350) +++ Lib/test/test_long.py (working copy) @@ -575,11 +575,13 @@ def __getslice__(self, i, j): return i, j - self.assertEqual(X()[-5L:7L], (-5, 7)) - # use the clamping effect to test the smallest and largest longs - # that fit a Py_ssize_t - slicemin, slicemax = X()[-2L**100:2L**100] - self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax)) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertEqual(X()[-5L:7L], (-5, 7)) + # use the clamping effect to test the smallest and largest longs + # that fit a Py_ssize_t + slicemin, slicemax = X()[-2L**100:2L**100] + self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax)) # ----------------------------------- tests of auto int->long conversion @@ -619,8 +621,10 @@ checkit(x, '*', y) if y: - expected = longx / longy - got = x / y + # Silence Py3k warning + with test_support.check_warnings(): + expected = longx / longy + got = x / y checkit(x, '/', y) expected = longx // longy Index: Lib/test/test_gzip.py =================================================================== --- Lib/test/test_gzip.py (revision 77350) +++ Lib/test/test_gzip.py (working copy) @@ -246,11 +246,11 @@ self.fail("__enter__ on a closed file didn't raise an exception") try: with gzip.GzipFile(self.filename, "wb") as f: - 1/0 + 1 // 0 except ZeroDivisionError: pass else: - self.fail("1/0 didn't raise an exception") + self.fail("1 // 0 didn't raise an exception") def test_main(verbose=None): test_support.run_unittest(TestGzip) Index: Lib/test/test_functools.py =================================================================== --- Lib/test/test_functools.py (revision 77350) +++ Lib/test/test_functools.py (working copy) @@ -116,7 +116,7 @@ def test_error_propagation(self): def f(x, y): - x / y + x // y self.assertRaises(ZeroDivisionError, self.thetype(f, 1, 0)) self.assertRaises(ZeroDivisionError, self.thetype(f, 1), 0) self.assertRaises(ZeroDivisionError, self.thetype(f), 1, 0) Index: Lib/test/test_syntax.py =================================================================== --- Lib/test/test_syntax.py (revision 77350) +++ Lib/test/test_syntax.py (working copy) @@ -552,7 +552,11 @@ def test_main(): test_support.run_unittest(SyntaxTestCase) from test import test_syntax - test_support.run_doctest(test_syntax, verbosity=True) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "backquote not supported", + SyntaxWarning) + test_support.run_doctest(test_syntax, verbosity=True) if __name__ == "__main__": test_main() Index: Lib/test/test_tarfile.py =================================================================== --- Lib/test/test_tarfile.py (revision 77350) +++ Lib/test/test_tarfile.py (working copy) @@ -712,7 +712,9 @@ return os.path.isfile(name) tar = tarfile.open(tmpname, self.mode, encoding="iso8859-1") - tar.add(tempdir, arcname="empty_dir", exclude=exclude) + # Silence Py3k warning + with test_support.check_warnings(): + tar.add(tempdir, arcname="empty_dir", exclude=exclude) tar.close() tar = tarfile.open(tmpname, "r") Index: Lib/test/test_fractions.py =================================================================== --- Lib/test/test_fractions.py (revision 77350) +++ Lib/test/test_fractions.py (working copy) @@ -43,6 +43,10 @@ assert False, "__sub__ should not be invoked for comparisons" __rsub__ = __sub__ + # Silence Py3k warning + def __hash__(self): + assert False, "__hash__ should not be invoked for comparisons" + class DummyRational(object): """Test comparison of Fraction with a naive rational implementation.""" @@ -76,6 +80,11 @@ def __float__(self): assert False, "__float__ should not be invoked" + # Silence Py3k warning + def __hash__(self): + assert False, "__hash__ should not be invoked for comparisons" + + class GcdTest(unittest.TestCase): def testMisc(self): Index: Lib/test/test_compile.py =================================================================== --- Lib/test/test_compile.py (revision 77350) +++ Lib/test/test_compile.py (working copy) @@ -2,6 +2,7 @@ import sys import _ast from test import test_support +import textwrap class TestSpecifics(unittest.TestCase): @@ -141,7 +142,9 @@ self.assertEqual(f(5), 0) def test_complex_args(self): - + # Silence Py3k warning + with test_support.check_warnings(): + exec textwrap.dedent(''' def comp_args((a, b)): return a,b self.assertEqual(comp_args((1, 2)), (1, 2)) @@ -159,6 +162,7 @@ return a, b, c self.assertEqual(comp_args(1, (2, 3)), (1, 2, 3)) self.assertEqual(comp_args(), (2, 3, 4)) + ''') def test_argument_order(self): try: Index: Lib/test/list_tests.py =================================================================== --- Lib/test/list_tests.py (revision 77350) +++ Lib/test/list_tests.py (working copy) @@ -4,7 +4,7 @@ import sys import os - +import warnings from test import test_support, seq_tests class CommonTest(seq_tests.CommonTest): @@ -36,7 +36,9 @@ self.assertEqual(str(a0), str(l0)) self.assertEqual(repr(a0), repr(l0)) - self.assertEqual(`a2`, `l2`) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertEqual(eval('`a2`'), eval('`l2`')) self.assertEqual(str(a2), "[0, 1, 2]") self.assertEqual(repr(a2), "[0, 1, 2]") @@ -421,6 +423,13 @@ self.assertRaises(TypeError, u.reverse, 42) def test_sort(self): + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "the cmp argument is not supported", + DeprecationWarning) + self._test_sort() + + def _test_sort(self): u = self.type2test([1, 0]) u.sort() self.assertEqual(u, [0, 1]) Index: Lib/test/test_rfc822.py =================================================================== --- Lib/test/test_rfc822.py (revision 77350) +++ Lib/test/test_rfc822.py (working copy) @@ -46,9 +46,9 @@ continue i = i + 1 self.assertEqual(mn, n, - "Un-expected name: %s != %s" % (`mn`, `n`)) + "Un-expected name: %r != %r" % (mn, n)) self.assertEqual(ma, a, - "Un-expected address: %s != %s" % (`ma`, `a`)) + "Un-expected address: %r != %r" % (ma, a)) if mn == n and ma == a: pass else: Index: Lib/test/test_json.py =================================================================== --- Lib/test/test_json.py (revision 77350) +++ Lib/test/test_json.py (working copy) @@ -7,10 +7,15 @@ import json.tests import test.test_support +import warnings def test_main(): - test.test_support.run_unittest(json.tests.test_suite()) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "comparing unequal types " + "not supported", DeprecationWarning) + test.test_support.run_unittest(json.tests.test_suite()) if __name__ == "__main__": Index: Lib/test/test_capi.py =================================================================== --- Lib/test/test_capi.py (revision 77350) +++ Lib/test/test_capi.py (working copy) @@ -55,7 +55,7 @@ context = foo() context.l = [] context.n = 2 #submits per thread - context.nThreads = n / context.n + context.nThreads = n // context.n context.nFinished = 0 context.lock = threading.Lock() context.event = threading.Event() Index: Lib/test/test_sort.py =================================================================== --- Lib/test/test_sort.py (revision 77350) +++ Lib/test/test_sort.py (working copy) @@ -2,6 +2,7 @@ import random import sys import unittest +import warnings verbose = test_support.verbose nerrors = 0 @@ -185,7 +186,7 @@ def test_stability(self): data = [(random.randrange(100), i) for i in xrange(200)] copy = data[:] - data.sort(key=lambda (x,y): x) # sort on the random first field + data.sort(key=lambda x: x[0]) # sort on the random first field copy.sort() # sort using both fields self.assertEqual(data, copy) # should get the same result @@ -207,7 +208,7 @@ # Verify that the wrapper has been removed data = range(-2,2) dup = data[:] - self.assertRaises(ZeroDivisionError, data.sort, None, lambda x: 1/x) + self.assertRaises(ZeroDivisionError, data.sort, None, lambda x: 1 // x) self.assertEqual(data, dup) def test_key_with_mutation(self): @@ -274,17 +275,21 @@ TestBugs, ) - test_support.run_unittest(*test_classes) - - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in xrange(len(counts)): - test_support.run_unittest(*test_classes) - gc.collect() - counts[i] = sys.gettotalrefcount() - print counts + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "the cmp argument is not supported", + DeprecationWarning) + test_support.run_unittest(*test_classes) + + # verify reference counting + if verbose and hasattr(sys, "gettotalrefcount"): + import gc + counts = [None] * 5 + for i in xrange(len(counts)): + test_support.run_unittest(*test_classes) + gc.collect() + counts[i] = sys.gettotalrefcount() + print counts if __name__ == "__main__": test_main(verbose=True) Index: Lib/test/test_operator.py =================================================================== --- Lib/test/test_operator.py (revision 77350) +++ Lib/test/test_operator.py (working copy) @@ -192,11 +192,12 @@ class C: pass def check(self, o, v): - self.assertTrue(operator.isCallable(o) == callable(o) == v) - check(self, 4, 0) - check(self, operator.isCallable, 1) - check(self, C, 1) - check(self, C(), 0) + with test_support.check_warnings(): + self.assertTrue(operator.isCallable(o) == callable(o) == v) + check(self, 4, False) + check(self, operator.isCallable, True) + check(self, C, True) + check(self, C(), False) def test_isMappingType(self): self.assertRaises(TypeError, operator.isMappingType) @@ -306,8 +307,10 @@ self.assertRaises(TypeError, operator.contains, None, None) self.assertTrue(operator.contains(range(4), 2)) self.assertFalse(operator.contains(range(4), 5)) - self.assertTrue(operator.sequenceIncludes(range(4), 2)) - self.assertFalse(operator.sequenceIncludes(range(4), 5)) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertTrue(operator.sequenceIncludes(range(4), 2)) + self.assertFalse(operator.sequenceIncludes(range(4), 5)) def test_setitem(self): a = range(3) Index: Lib/test/test_types.py =================================================================== --- Lib/test/test_types.py (revision 77350) +++ Lib/test/test_types.py (working copy) @@ -4,6 +4,7 @@ import unittest import sys import locale +import warnings class TypesTests(unittest.TestCase): @@ -710,7 +711,13 @@ self.assertRaises(ValueError, format, 0, ',' + code) def test_main(): - run_unittest(TypesTests) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "buffer.. not supported", + DeprecationWarning) + warnings.filterwarnings("ignore", "classic long division", + DeprecationWarning) + run_unittest(TypesTests) if __name__ == '__main__': test_main() Index: Lib/test/test_compiler.py =================================================================== --- Lib/test/test_compiler.py (revision 77350) +++ Lib/test/test_compiler.py (working copy) @@ -75,7 +75,7 @@ def testTryExceptFinally(self): # Test that except and finally clauses in one try stmt are recognized - c = compiler.compile("try:\n 1/0\nexcept:\n e = 1\nfinally:\n f = 1", + c = compiler.compile("try:\n 1//0\nexcept:\n e = 1\nfinally:\n f = 1", "", "exec") dct = {} exec c in dct Index: Lib/test/test_peepholer.py =================================================================== --- Lib/test/test_peepholer.py (revision 77350) +++ Lib/test/test_peepholer.py (working copy) @@ -205,18 +205,24 @@ def test_main(verbose=None): import sys from test import test_support + import warnings test_classes = (TestTranforms,) - test_support.run_unittest(*test_classes) - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in xrange(len(counts)): - test_support.run_unittest(*test_classes) - gc.collect() - counts[i] = sys.gettotalrefcount() - print counts + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "backquote not supported", + SyntaxWarning) + test_support.run_unittest(*test_classes) + + # verify reference counting + if verbose and hasattr(sys, "gettotalrefcount"): + import gc + counts = [None] * 5 + for i in xrange(len(counts)): + test_support.run_unittest(*test_classes) + gc.collect() + counts[i] = sys.gettotalrefcount() + print counts if __name__ == "__main__": test_main(verbose=True) Index: Lib/test/test_ossaudiodev.py =================================================================== --- Lib/test/test_ossaudiodev.py (revision 77350) +++ Lib/test/test_ossaudiodev.py (working copy) @@ -71,7 +71,7 @@ self.fail("dsp.%s not read-only" % attr) # Compute expected running time of sound sample (in seconds). - expected_time = float(len(data)) / (ssize/8) / nchannels / rate + expected_time = float(len(data)) / (ssize//8) / nchannels / rate # set parameters based on .au file headers dsp.setparameters(AFMT_S16_NE, nchannels, rate) Index: Lib/test/test_zipimport_support.py =================================================================== --- Lib/test/test_zipimport_support.py (revision 77350) +++ Lib/test/test_zipimport_support.py (working copy) @@ -168,8 +168,11 @@ test_zipped_doctest.test_testfile, test_zipped_doctest.test_unittest_reportflags, ] - for obj in known_good_tests: - _run_object_doctest(obj, test_zipped_doctest) + # Silence Py3k warning + # Needed for test_DocTestParser and test_debug + with test.test_support.check_warnings(): + for obj in known_good_tests: + _run_object_doctest(obj, test_zipped_doctest) def test_doctest_main_issue4197(self): test_src = textwrap.dedent("""\ Index: Lib/test/test_pyexpat.py =================================================================== --- Lib/test/test_pyexpat.py (revision 77350) +++ Lib/test/test_pyexpat.py (working copy) @@ -554,7 +554,7 @@ self.n=0 parser.Parse(xml1, 0) - parser.buffer_size /= 2 + parser.buffer_size //= 2 self.assertEquals(parser.buffer_size, 1024) parser.Parse(xml2, 1) self.assertEquals(self.n, 4) Index: Lib/test/test_cgi.py =================================================================== --- Lib/test/test_cgi.py (revision 77350) +++ Lib/test/test_cgi.py (working copy) @@ -104,7 +104,7 @@ def norm(list): if type(list) == type([]): - list.sort() + list.sort(key=str) return list def first_elts(list): Index: Lib/test/test_buffer.py =================================================================== --- Lib/test/test_buffer.py (revision 77350) +++ Lib/test/test_buffer.py (working copy) @@ -6,6 +6,7 @@ import unittest from test import test_support +import warnings class BufferTests(unittest.TestCase): @@ -23,7 +24,11 @@ def test_main(): - test_support.run_unittest(BufferTests) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "buffer.. not supported", + DeprecationWarning) + test_support.run_unittest(BufferTests) if __name__ == "__main__": test_main() Index: Lib/test/test_scope.py =================================================================== --- Lib/test/test_scope.py (revision 77350) +++ Lib/test/test_scope.py (working copy) @@ -321,10 +321,16 @@ self.assertEqual(makeReturner2(a=11)()['a'], 11) - def makeAddPair((a, b)): - def addPair((c, d)): - return (a + c, b + d) - return addPair + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "tuple parameter unpacking " + "has been removed", SyntaxWarning) + exec """\ +def makeAddPair((a, b)): + def addPair((c, d)): + return (a + c, b + d) + return addPair +""" in locals() self.assertEqual(makeAddPair((1, 2))((100, 200)), (101,202)) @@ -471,7 +477,7 @@ return g d = f(2)(4) - self.assertTrue(d.has_key('h')) + self.assertTrue('h' in d) del d['h'] self.assertEqual(d, {'x': 2, 'y': 7, 'w': 6}) Index: Lib/test/test_queue.py =================================================================== --- Lib/test/test_queue.py (revision 77350) +++ Lib/test/test_queue.py (working copy) @@ -7,7 +7,8 @@ import unittest from test import test_support -QUEUE_SIZE = 5 +QUEUE_SIZE = LAST = 5 +FULL = LAST+1 # A thread to run a function that unclogs a blocked Queue. class _TriggerThread(threading.Thread): @@ -102,21 +103,21 @@ q.put(i) self.assertTrue(not q.empty(), "Queue should not be empty") self.assertTrue(not q.full(), "Queue should not be full") - q.put("last") + q.put(LAST) self.assertTrue(q.full(), "Queue should be full") try: - q.put("full", block=0) + q.put(FULL, block=0) self.fail("Didn't appear to block with a full queue") except Queue.Full: pass try: - q.put("full", timeout=0.01) + q.put(FULL, timeout=0.01) self.fail("Didn't appear to time-out with a full queue") except Queue.Full: pass # Test a blocking put - self.do_blocking_test(q.put, ("full",), q.get, ()) - self.do_blocking_test(q.put, ("full", True, 10), q.get, ()) + self.do_blocking_test(q.put, (FULL,), q.get, ()) + self.do_blocking_test(q.put, (FULL, True, 10), q.get, ()) # Empty it for i in range(QUEUE_SIZE): q.get() Index: Lib/test/test_marshal.py =================================================================== --- Lib/test/test_marshal.py (revision 77350) +++ Lib/test/test_marshal.py (working copy) @@ -129,7 +129,9 @@ def test_buffer(self): for s in ["", "Andrč Previn", "abc", " "*10000]: - b = buffer(s) + # Silence Py3k warning + with test_support.check_warnings(): + b = buffer(s) new = marshal.loads(marshal.dumps(b)) self.assertEqual(s, new) marshal.dump(b, file(test_support.TESTFN, "wb")) Index: Lib/test/test_urllibnet.py =================================================================== --- Lib/test/test_urllibnet.py (revision 77350) +++ Lib/test/test_urllibnet.py (working copy) @@ -7,7 +7,7 @@ import urllib import sys import os -import mimetools +mimetools = test_support.import_module("mimetools", deprecated=True) def _open_with_retry(func, host, *args, **kwargs): Index: Lib/test/test_iter.py =================================================================== --- Lib/test/test_iter.py (revision 77350) +++ Lib/test/test_iter.py (working copy) @@ -1,7 +1,8 @@ # Test iterators. import unittest -from test.test_support import run_unittest, TESTFN, unlink, have_unicode +from test.test_support import run_unittest, TESTFN, unlink, have_unicode, \ + check_warnings # Test result of triple loop (too big to inline) TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2), @@ -395,7 +396,12 @@ pass # Test map()'s use of iterators. - def test_builtin_map(self): + def test_deprecated_builtin_map(self): + # Silence Py3k warning + with check_warnings(): + self._test_builtin_map() + + def _test_builtin_map(self): self.assertEqual(map(None, SequenceClass(5)), range(5)) self.assertEqual(map(lambda x: x+1, SequenceClass(5)), range(1, 6)) @@ -506,7 +512,12 @@ self.assertEqual(zip(x, y), expected) # Test reduces()'s use of iterators. - def test_builtin_reduce(self): + def test_deprecated_builtin_reduce(self): + # Silence Py3k warning + with check_warnings(): + self._test_builtin_reduce() + + def _test_builtin_reduce(self): from operator import add self.assertEqual(reduce(add, SequenceClass(5)), 10) self.assertEqual(reduce(add, SequenceClass(5), 42), 52) Index: Lib/test/test_whichdb.py =================================================================== --- Lib/test/test_whichdb.py (revision 77350) +++ Lib/test/test_whichdb.py (working copy) @@ -7,11 +7,13 @@ import test.test_support import unittest import whichdb -import anydbm import glob _fname = test.test_support.TESTFN +# Silence Py3k warning +anydbm = test.test_support.import_module('anydbm', deprecated=True) + def _delete_files(): # we don't know the precise name the underlying database uses # so we use glob to locate all names @@ -37,8 +39,9 @@ # we define a new test method for each # candidate database module. try: - mod = __import__(name) - except ImportError: + # Silence Py3k warning + mod = test.test_support.import_module(name, deprecated=True) + except unittest.SkipTest: continue def test_whichdb_name(self, name=name, mod=mod): Index: Lib/test/seq_tests.py =================================================================== --- Lib/test/seq_tests.py (revision 77350) +++ Lib/test/seq_tests.py (working copy) @@ -4,6 +4,7 @@ import unittest import sys +import test_support # Various iterables # This is used for checking the constructor (here and in test_deque.py) @@ -196,7 +197,9 @@ self.assertEqual(a[ -pow(2,128L): 3 ], self.type2test([0,1,2])) self.assertEqual(a[ 3: pow(2,145L) ], self.type2test([3,4])) - self.assertRaises(TypeError, u.__getslice__) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertRaises(TypeError, u.__getslice__) def test_contains(self): u = self.type2test([0, 1, 2]) Index: Lib/test/mapping_tests.py =================================================================== --- Lib/test/mapping_tests.py (revision 77350) +++ Lib/test/mapping_tests.py (working copy) @@ -1,6 +1,7 @@ # tests common to dict and UserDict import unittest import UserDict +import test_support class BasicTestMappingProtocol(unittest.TestCase): @@ -54,13 +55,18 @@ #len self.assertEqual(len(p), 0) self.assertEqual(len(d), len(self.reference)) - #has_key + #in for k in self.reference: - self.assertTrue(d.has_key(k)) self.assertTrue(k in d) for k in self.other: - self.assertFalse(d.has_key(k)) self.assertFalse(k in d) + #has_key + # Silence Py3k warning + with test_support.check_warnings(): + for k in self.reference: + self.assertTrue(d.has_key(k)) + for k in self.other: + self.assertFalse(d.has_key(k)) #cmp self.assertEqual(cmp(p,p), 0) self.assertEqual(cmp(d,d), 0) Index: Lib/test/test_sets.py =================================================================== --- Lib/test/test_sets.py (revision 77350) +++ Lib/test/test_sets.py (working copy) @@ -510,15 +510,17 @@ self.assertEqual(self.set != self.other, True) def test_ge_gt_le_lt(self): - self.assertRaises(TypeError, lambda: self.set < self.other) - self.assertRaises(TypeError, lambda: self.set <= self.other) - self.assertRaises(TypeError, lambda: self.set > self.other) - self.assertRaises(TypeError, lambda: self.set >= self.other) - - self.assertRaises(TypeError, lambda: self.other < self.set) - self.assertRaises(TypeError, lambda: self.other <= self.set) - self.assertRaises(TypeError, lambda: self.other > self.set) - self.assertRaises(TypeError, lambda: self.other >= self.set) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertRaises(TypeError, lambda: self.set < self.other) + self.assertRaises(TypeError, lambda: self.set <= self.other) + self.assertRaises(TypeError, lambda: self.set > self.other) + self.assertRaises(TypeError, lambda: self.set >= self.other) + + self.assertRaises(TypeError, lambda: self.other < self.set) + self.assertRaises(TypeError, lambda: self.other <= self.set) + self.assertRaises(TypeError, lambda: self.other > self.set) + self.assertRaises(TypeError, lambda: self.other >= self.set) def test_union_update_operator(self): try: @@ -679,20 +681,20 @@ def test_copy(self): dup = self.set.copy() - dup_list = list(dup); dup_list.sort() - set_list = list(self.set); set_list.sort() + dup_list = list(dup) + set_list = list(self.set) self.assertEqual(len(dup_list), len(set_list)) - for i in range(len(dup_list)): - self.assertTrue(dup_list[i] is set_list[i]) + for elt in dup_list: + self.assertTrue(elt in set_list) def test_deep_copy(self): dup = copy.deepcopy(self.set) ##print type(dup), repr(dup) - dup_list = list(dup); dup_list.sort() - set_list = list(self.set); set_list.sort() + dup_list = list(dup) + set_list = list(self.set) self.assertEqual(len(dup_list), len(set_list)) - for i in range(len(dup_list)): - self.assertEqual(dup_list[i], set_list[i]) + for elt in dup_list: + self.assertTrue(elt in set_list) #------------------------------------------------------------------------------ Index: Lib/test/test_binascii.py =================================================================== --- Lib/test/test_binascii.py (revision 77350) +++ Lib/test/test_binascii.py (working copy) @@ -26,10 +26,10 @@ prefixes.extend(["crc_", "rlecode_", "rledecode_"]) for prefix in prefixes: name = prefix + suffix - self.assertTrue(callable(getattr(binascii, name))) + self.assertTrue(hasattr(getattr(binascii, name), '__call__')) self.assertRaises(TypeError, getattr(binascii, name)) for name in ("hexlify", "unhexlify"): - self.assertTrue(callable(getattr(binascii, name))) + self.assertTrue(hasattr(getattr(binascii, name), '__call__')) self.assertRaises(TypeError, getattr(binascii, name)) def test_base64valid(self): Index: Lib/test/inspect_fodder.py =================================================================== --- Lib/test/inspect_fodder.py (revision 77350) +++ Lib/test/inspect_fodder.py (working copy) @@ -15,7 +15,7 @@ fr = inspect.currentframe() st = inspect.stack() p = x - q = y / 0 + q = y // 0 # line 20 class StupidGit: Index: Lib/test/test_wsgiref.py =================================================================== --- Lib/test/test_wsgiref.py (revision 77350) +++ Lib/test/test_wsgiref.py (working copy) @@ -432,10 +432,10 @@ env = handler.environ from os import environ for k,v in environ.items(): - if not empty.has_key(k): + if k not in empty: self.assertEqual(env[k],v) for k,v in empty.items(): - self.assertTrue(env.has_key(k)) + self.assertTrue(k in env) def testEnviron(self): h = TestHandler(X="Y") @@ -448,7 +448,7 @@ h = BaseCGIHandler(None,None,None,{}) h.setup_environ() for key in 'wsgi.url_scheme', 'wsgi.input', 'wsgi.errors': - self.assertTrue(h.environ.has_key(key)) + self.assertTrue(key in h.environ) def testScheme(self): h=TestHandler(HTTPS="on"); h.setup_environ() Index: Lib/test/test_univnewlines2k.py =================================================================== --- Lib/test/test_univnewlines2k.py (revision 77350) +++ Lib/test/test_univnewlines2k.py (working copy) @@ -80,7 +80,9 @@ def test_execfile(self): namespace = {} - execfile(test_support.TESTFN, namespace) + # Silence Py3k warning + with test_support.check_warnings(): + execfile(test_support.TESTFN, namespace) func = namespace['line3'] self.assertEqual(func.func_code.co_firstlineno, 3) self.assertEqual(namespace['line4'], FATX) Index: Lib/test/test_grammar.py =================================================================== --- Lib/test/test_grammar.py (revision 77350) +++ Lib/test/test_grammar.py (working copy) @@ -11,6 +11,7 @@ from test.test_support import run_unittest, check_syntax_error import unittest import sys +import warnings # testing import * from sys import * @@ -152,8 +153,9 @@ f1(*(), **{}) def f2(one_argument): pass def f3(two, arguments): pass - def f4(two, (compound, (argument, list))): pass - def f5((compound, first), two): pass + # Silence Py3k warning + exec('def f4(two, (compound, (argument, list))): pass') + exec('def f5((compound, first), two): pass') self.assertEquals(f2.func_code.co_varnames, ('one_argument',)) self.assertEquals(f3.func_code.co_varnames, ('two', 'arguments')) if sys.platform.startswith('java'): @@ -172,7 +174,8 @@ def v0(*rest): pass def v1(a, *rest): pass def v2(a, b, *rest): pass - def v3(a, (b, c), *rest): return a, b, c, rest + # Silence Py3k warning + exec('def v3(a, (b, c), *rest): return a, b, c, rest') f1() f2(1) @@ -277,9 +280,10 @@ d22v(*(1, 2, 3, 4)) d22v(1, 2, *(3, 4, 5)) d22v(1, *(2, 3), **{'d': 4}) - def d31v((x)): pass + # Silence Py3k warning + exec('def d31v((x)): pass') + exec('def d32v((x,)): pass') d31v(1) - def d32v((x,)): pass d32v((1,)) # keyword arguments after *arglist @@ -474,7 +478,7 @@ continue except: raise - if count > 2 or big_hippo <> 1: + if count > 2 or big_hippo != 1: self.fail("continue then break in try/except in loop broken!") test_inner() @@ -677,7 +681,6 @@ x = (1 == 1) if 1 == 1: pass if 1 != 1: pass - if 1 <> 1: pass if 1 < 1: pass if 1 > 1: pass if 1 <= 1: pass @@ -686,7 +689,10 @@ if 1 is not 1: pass if 1 in (): pass if 1 not in (): pass - if 1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1: pass + if 1 < 1 > 1 == 1 >= 1 <= 1 != 1 in 1 not in 1 is 1 is not 1: pass + # Silence Py3k warning + if eval('1 <> 1'): pass + if eval('1 < 1 > 1 == 1 >= 1 <= 1 <> 1 != 1 in 1 not in 1 is 1 is not 1'): pass def testBinaryMaskOps(self): x = 1 & 1 @@ -769,9 +775,10 @@ x = {'one': 1, 'two': 2,} x = {'one': 1, 'two': 2, 'three': 3, 'four': 4, 'five': 5, 'six': 6} - x = `x` - x = `1 or 2 or 3` - self.assertEqual(`1,2`, '(1, 2)') + # Silence Py3k warning + x = eval('`x`') + x = eval('`1 or 2 or 3`') + self.assertEqual(eval('`1,2`'), '(1, 2)') x = x x = 'x' @@ -976,7 +983,19 @@ def test_main(): - run_unittest(TokenTests, GrammarTests) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "backquote not supported", + SyntaxWarning) + warnings.filterwarnings("ignore", "tuple parameter unpacking has been removed", + SyntaxWarning) + warnings.filterwarnings("ignore", "parenthesized argument names are invalid", + SyntaxWarning) + warnings.filterwarnings("ignore", "classic int division", + DeprecationWarning) + warnings.filterwarnings("ignore", ".+ not supported in 3.x", + DeprecationWarning) + run_unittest(TokenTests, GrammarTests) if __name__ == '__main__': test_main() Index: Lib/test/test_shelve.py =================================================================== --- Lib/test/test_shelve.py (revision 77350) +++ Lib/test/test_shelve.py (working copy) @@ -4,6 +4,8 @@ import glob from test import test_support +test_support.import_module('anydbm', deprecated=True) + class TestCase(unittest.TestCase): fn = "shelftemp" + os.extsep + "db" Index: Lib/test/test_hotshot.py =================================================================== --- Lib/test/test_hotshot.py (revision 77350) +++ Lib/test/test_hotshot.py (working copy) @@ -1,5 +1,3 @@ -import hotshot -import hotshot.log import os import pprint import unittest @@ -9,6 +7,8 @@ from test import test_support +# Silence Py3k warning +hotshot = test_support.import_module('hotshot', deprecated=True) from hotshot.log import ENTER, EXIT, LINE Index: Lib/test/test_mutants.py =================================================================== --- Lib/test/test_mutants.py (revision 77350) +++ Lib/test/test_mutants.py (working copy) @@ -210,7 +210,7 @@ # Tim sez: "luck of the draw; crashes with or without for me." print >> f - return `"machiavelli"` + return repr("machiavelli") def __hash__(self): return 0 Index: Lib/test/test_decimal.py =================================================================== --- Lib/test/test_decimal.py (revision 77350) +++ Lib/test/test_decimal.py (working copy) @@ -31,7 +31,8 @@ import unittest from decimal import * import numbers -from test.test_support import (run_unittest, run_doctest, is_resource_enabled) +from test.test_support import (run_unittest, run_doctest, + is_resource_enabled, check_warnings) import random try: import threading @@ -202,7 +203,7 @@ if skip_expected: raise unittest.SkipTest return - for line in open(file).xreadlines(): + for line in open(file): line = line.replace('\r\n', '').replace('\n', '') #print line try: @@ -361,8 +362,10 @@ myexceptions = self.getexceptions() self.context.clear_flags() - myexceptions.sort() - theirexceptions.sort() + # Silence Py3k warning + with check_warnings(): + myexceptions.sort() + theirexceptions.sort() self.assertEqual(result, ans, 'Incorrect answer for ' + s + ' -- got ' + result) @@ -617,12 +620,14 @@ ('//', '__floordiv__', '__rfloordiv__'), ('**', '__pow__', '__rpow__') ] - if 1/2 == 0: - # testing with classic division, so add __div__ - oplist.append(('/', '__div__', '__rdiv__')) - else: - # testing with -Qnew, so add __truediv__ - oplist.append(('/', '__truediv__', '__rtruediv__')) + # Silence Py3k warning + with check_warnings(): + if 1/2 == 0: + # testing with classic division, so add __div__ + oplist.append(('/', '__div__', '__rdiv__')) + else: + # testing with -Qnew, so add __truediv__ + oplist.append(('/', '__truediv__', '__rtruediv__')) for sym, lop, rop in oplist: setattr(E, lop, lambda self, other: 'str' + lop + str(other)) @@ -1194,8 +1199,10 @@ self.assertEqual(a, b) # with None - self.assertFalse(Decimal(1) < None) - self.assertTrue(Decimal(1) > None) + # Silence Py3k warning + with check_warnings(): + self.assertFalse(Decimal(1) < None) + self.assertTrue(Decimal(1) > None) def test_copy_and_deepcopy_methods(self): d = Decimal('43.24') @@ -1704,11 +1711,14 @@ for flag in extra_flags: if flag not in expected_flags: expected_flags.append(flag) - expected_flags.sort() # flags we actually got new_flags = [k for k,v in context.flags.items() if v] - new_flags.sort() + + # Silence Py3k warning + with check_warnings(): + expected_flags.sort() + new_flags.sort() self.assertEqual(ans, new_ans, "operation produces different answers depending on flags set: " + Index: Lib/test/test_undocumented_details.py =================================================================== --- Lib/test/test_undocumented_details.py (revision 77350) +++ Lib/test/test_undocumented_details.py (working copy) @@ -1,4 +1,4 @@ -from test.test_support import run_unittest, have_unicode +from test.test_support import run_unittest, check_warnings import unittest import sys @@ -33,7 +33,9 @@ self.assertTrue(g_cell != h_cell) def test_main(): - run_unittest(TestImplementationComparisons) + # Silence Py3k warnings + with check_warnings(): + run_unittest(TestImplementationComparisons) if __name__ == '__main__': test_main() Index: Lib/test/test_xpickle.py =================================================================== --- Lib/test/test_xpickle.py (revision 77350) +++ Lib/test/test_xpickle.py (working copy) @@ -25,7 +25,7 @@ mod_path = os.path.abspath(os.path.join(os.path.dirname(__file__), "pickletester.py")) pickletester = types.ModuleType("test.pickletester") -execfile(mod_path, pickletester.__dict__, pickletester.__dict__) +exec compile(open(mod_path).read(), mod_path, 'exec') in pickletester.__dict__ AbstractPickleTests = pickletester.AbstractPickleTests if pickletester.__name__ in sys.modules: raise RuntimeError("Did not expect to find test.pickletester loaded") Index: Lib/test/test_commands.py =================================================================== --- Lib/test/test_commands.py (revision 77350) +++ Lib/test/test_commands.py (working copy) @@ -9,7 +9,10 @@ warnings.filterwarnings('ignore', r".*commands.getstatus.. is deprecated", DeprecationWarning) -from test.test_support import run_unittest, reap_children +from test.test_support import run_unittest, reap_children, import_module + +# Silence Py3k warning +import_module('commands', deprecated=True) from commands import * # The module says: Index: Lib/test/test_ftplib.py =================================================================== --- Lib/test/test_ftplib.py (revision 77350) +++ Lib/test/test_ftplib.py (working copy) @@ -100,7 +100,7 @@ sock.listen(5) sock.settimeout(2) ip, port = sock.getsockname()[:2] - ip = ip.replace('.', ','); p1 = port / 256; p2 = port % 256 + ip = ip.replace('.', ','); p1, p2 = divmod(port, 256) self.push('227 entering passive mode (%s,%d,%d)' %(ip, p1, p2)) conn, addr = sock.accept() self.dtp = self.dtp_handler(conn, baseclass=self) Index: Lib/test/test_random.py =================================================================== --- Lib/test/test_random.py (revision 77350) +++ Lib/test/test_random.py (working copy) @@ -6,6 +6,7 @@ import pickle import warnings from math import log, exp, sqrt, pi, fsum, sin +from functools import reduce from test import test_support class TestBasicOps(unittest.TestCase): Index: Lib/test/test_struct.py =================================================================== --- Lib/test/test_struct.py (revision 77350) +++ Lib/test/test_struct.py (working copy) @@ -471,7 +471,7 @@ def test_bool(self): for prefix in tuple("<>!=")+('',): false = (), [], [], '', 0 - true = [1], 'test', 5, -1, 0xffffffffL+1, 0xffffffff/2 + true = [1], 'test', 5, -1, 0xffffffffL+1, 0xffffffff//2 falseFormat = prefix + '?' * len(false) packedFalse = struct.pack(falseFormat, *false) @@ -507,7 +507,11 @@ def test_main(): - run_unittest(StructTest) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "buffer.. not supported", + DeprecationWarning) + run_unittest(StructTest) if __name__ == '__main__': test_main() Index: Lib/test/test_weakref.py =================================================================== --- Lib/test/test_weakref.py (revision 77350) +++ Lib/test/test_weakref.py (working copy) @@ -54,10 +54,10 @@ # Live reference: o = C() wr = weakref.ref(o) - `wr` + repr(wr) # Dead reference: del o - `wr` + repr(wr) def test_basic_callback(self): self.check_basic_callback(C) @@ -169,7 +169,9 @@ p.append(12) self.assertEqual(len(L), 1) self.assertTrue(p, "proxy for non-empty UserList should be true") - p[:] = [2, 3] + # Silence Py3k warning + with test_support.check_warnings(): + p[:] = [2, 3] self.assertEqual(len(L), 2) self.assertEqual(len(p), 2) self.assertTrue(3 in p, @@ -183,10 +185,12 @@ ## self.assertEqual(repr(L2), repr(p2)) L3 = UserList.UserList(range(10)) p3 = weakref.proxy(L3) - self.assertEqual(L3[:], p3[:]) - self.assertEqual(L3[5:], p3[5:]) - self.assertEqual(L3[:5], p3[:5]) - self.assertEqual(L3[2:5], p3[2:5]) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertEqual(L3[:], p3[:]) + self.assertEqual(L3[5:], p3[5:]) + self.assertEqual(L3[:5], p3[:5]) + self.assertEqual(L3[2:5], p3[2:5]) def test_proxy_unicode(self): # See bug 5037 @@ -832,7 +836,7 @@ def test_weak_keys(self): # # This exercises d.copy(), d.items(), d[] = v, d[], del d[], - # len(d), d.has_key(). + # len(d), in d. # dict, objects = self.make_weak_keyed_dict() for o in objects: @@ -854,8 +858,8 @@ "deleting the keys did not clear the dictionary") o = Object(42) dict[o] = "What is the meaning of the universe?" - self.assertTrue(dict.has_key(o)) - self.assertTrue(not dict.has_key(34)) + self.assertTrue(o in dict) + self.assertTrue(34 not in dict) def test_weak_keyed_iters(self): dict, objects = self.make_weak_keyed_dict() @@ -867,7 +871,7 @@ objects2 = list(objects) for wr in refs: ob = wr() - self.assertTrue(dict.has_key(ob)) + self.assertTrue(ob in dict) self.assertTrue(ob in dict) self.assertEqual(ob.arg, dict[ob]) objects2.remove(ob) @@ -878,7 +882,6 @@ self.assertEqual(len(list(dict.iterkeyrefs())), len(objects)) for wr in dict.iterkeyrefs(): ob = wr() - self.assertTrue(dict.has_key(ob)) self.assertTrue(ob in dict) self.assertEqual(ob.arg, dict[ob]) objects2.remove(ob) @@ -993,13 +996,13 @@ weakdict = klass() o = weakdict.setdefault(key, value1) self.assertTrue(o is value1) - self.assertTrue(weakdict.has_key(key)) + self.assertTrue(key in weakdict) self.assertTrue(weakdict.get(key) is value1) self.assertTrue(weakdict[key] is value1) o = weakdict.setdefault(key, value2) self.assertTrue(o is value1) - self.assertTrue(weakdict.has_key(key)) + self.assertTrue(key in weakdict) self.assertTrue(weakdict.get(key) is value1) self.assertTrue(weakdict[key] is value1) @@ -1013,20 +1016,20 @@ def check_update(self, klass, dict): # - # This exercises d.update(), len(d), d.keys(), d.has_key(), + # This exercises d.update(), len(d), d.keys(), in d, # d.get(), d[]. # weakdict = klass() weakdict.update(dict) self.assertTrue(len(weakdict) == len(dict)) for k in weakdict.keys(): - self.assertTrue(dict.has_key(k), + self.assertTrue(k in dict, "mysterious new key appeared in weak dict") v = dict.get(k) self.assertTrue(v is weakdict[k]) self.assertTrue(v is weakdict.get(k)) for k in dict.keys(): - self.assertTrue(weakdict.has_key(k), + self.assertTrue(k in weakdict, "original key disappeared in weak dict") v = dict[k] self.assertTrue(v is weakdict[k]) Index: Lib/test/test_bool.py =================================================================== --- Lib/test/test_bool.py (revision 77350) +++ Lib/test/test_bool.py (working copy) @@ -91,10 +91,10 @@ self.assertEqual(False*1, 0) self.assertIsNot(False*1, False) - self.assertEqual(True/1, 1) - self.assertIsNot(True/1, True) - self.assertEqual(False/1, 0) - self.assertIsNot(False/1, False) + self.assertEqual(True//1, 1) + self.assertIsNot(True//1, True) + self.assertEqual(False//1, 0) + self.assertIsNot(False//1, False) for b in False, True: for i in 0, 1, 2: @@ -168,8 +168,8 @@ self.assertIs(hasattr([], "wobble"), False) def test_callable(self): - self.assertIs(callable(len), True) - self.assertIs(callable(1), False) + self.assertTrue(hasattr(len, '__call__'), True) + self.assertFalse(hasattr(1, '__call__'), False) def test_isinstance(self): self.assertIs(isinstance(True, bool), True) @@ -184,8 +184,12 @@ self.assertIs(issubclass(int, bool), False) def test_haskey(self): - self.assertIs({}.has_key(1), False) - self.assertIs({1:1}.has_key(1), True) + self.assertIs(1 in {}, False) + self.assertIs(1 in {1:1}, True) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertIs({}.has_key(1), False) + self.assertIs({1:1}.has_key(1), True) def test_string(self): self.assertIs("xyz".endswith("z"), True) @@ -257,8 +261,10 @@ import operator self.assertIs(operator.truth(0), False) self.assertIs(operator.truth(1), True) - self.assertIs(operator.isCallable(0), False) - self.assertIs(operator.isCallable(len), True) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertIs(operator.isCallable(0), False) + self.assertIs(operator.isCallable(len), True) self.assertIs(operator.isNumberType(None), False) self.assertIs(operator.isNumberType(0), True) self.assertIs(operator.not_(1), False) Index: Lib/test/test_slice.py =================================================================== --- Lib/test/test_slice.py (revision 77350) +++ Lib/test/test_slice.py (working copy) @@ -115,7 +115,9 @@ tmp.append((i, j, k)) x = X() - x[1:2] = 42 + # Silence Py3k warning + with test_support.check_warnings(): + x[1:2] = 42 self.assertEquals(tmp, [(1, 2, 42)]) def test_pickle(self): Index: Lib/test/test_import.py =================================================================== --- Lib/test/test_import.py (revision 77350) +++ Lib/test/test_import.py (working copy) @@ -7,6 +7,7 @@ import py_compile import warnings import marshal +from imp import reload from test.test_support import (unlink, TESTFN, unload, run_unittest, check_warnings, TestFailed, EnvironmentVarGuard) @@ -56,11 +57,10 @@ f.close() try: - try: - mod = __import__(TESTFN) - except ImportError, err: - self.fail("import from %s failed: %s" % (ext, err)) - + mod = __import__(TESTFN) + except ImportError, err: + self.fail("import from %s failed: %s" % (ext, err)) + else: self.assertEquals(mod.a, a, "module loaded (%s) but contents invalid" % mod) self.assertEquals(mod.b, b, @@ -69,10 +69,9 @@ os.unlink(source) try: - try: - reload(mod) - except ImportError, err: - self.fail("import from .pyc/.pyo failed: %s" % err) + reload(mod) + except ImportError, err: + self.fail("import from .pyc/.pyo failed: %s" % err) finally: try: os.unlink(pyc) @@ -172,7 +171,7 @@ def test_failing_import_sticks(self): source = TESTFN + os.extsep + "py" f = open(source, "w") - print >> f, "a = 1/0" + print >> f, "a = 1 // 0" f.close() # New in 2.4, we shouldn't be able to import that no matter how often Index: Lib/test/test_anydbm.py =================================================================== --- Lib/test/test_anydbm.py (revision 77350) +++ Lib/test/test_anydbm.py (working copy) @@ -5,12 +5,14 @@ import os import unittest -import anydbm import glob from test import test_support _fname = test_support.TESTFN +# Silence Py3k warning +anydbm = test_support.import_module('anydbm', deprecated=True) + def _delete_files(): # we don't know the precise name the underlying database uses # so we use glob to locate all names Index: Lib/test/test_unittest.py =================================================================== --- Lib/test/test_unittest.py (revision 77350) +++ Lib/test/test_unittest.py (working copy) @@ -3056,7 +3056,7 @@ try: self.assertRaises(KeyError, lambda: None) except self.failureException as e: - self.assert_("KeyError not raised" in e, str(e)) + self.assert_("KeyError not raised" in e.args, str(e)) else: self.fail("assertRaises() didn't fail") try: @@ -3073,7 +3073,7 @@ with self.assertRaises(KeyError): pass except self.failureException as e: - self.assert_("KeyError not raised" in e, str(e)) + self.assert_("KeyError not raised" in e.args, str(e)) else: self.fail("assertRaises() didn't fail") try: @@ -3591,6 +3591,9 @@ def __eq__(self, other): return self.path == other.path + # Silence Py3k warning + __hash__ = None + loader._get_module_from_name = lambda name: Module(name) def loadTestsFromModule(module, use_load_tests): if use_load_tests: Index: Lib/test/test_multifile.py =================================================================== --- Lib/test/test_multifile.py (revision 77350) +++ Lib/test/test_multifile.py (working copy) @@ -1,5 +1,5 @@ from test import test_support -import mimetools +mimetools = test_support.import_module("mimetools", deprecated=True) multifile = test_support.import_module('multifile', deprecated=True) import cStringIO Index: Lib/test/test_sqlite.py =================================================================== --- Lib/test/test_sqlite.py (revision 77350) +++ Lib/test/test_sqlite.py (working copy) @@ -4,14 +4,21 @@ # Skip test if _sqlite3 module was not built. import_module('_sqlite3') +import warnings from sqlite3.test import (dbapi, types, userfunctions, py25tests, factory, transactions, hooks, regression, dump) def test_main(): - run_unittest(dbapi.suite(), types.suite(), userfunctions.suite(), - py25tests.suite(), factory.suite(), transactions.suite(), - hooks.suite(), regression.suite(), dump.suite()) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", "buffer.. not supported", + DeprecationWarning) + warnings.filterwarnings("ignore", "classic int division", + DeprecationWarning) + run_unittest(dbapi.suite(), types.suite(), userfunctions.suite(), + py25tests.suite(), factory.suite(), transactions.suite(), + hooks.suite(), regression.suite(), dump.suite()) if __name__ == "__main__": test_main() Index: Lib/test/test_binop.py =================================================================== --- Lib/test/test_binop.py (revision 77350) +++ Lib/test/test_binop.py (working copy) @@ -207,6 +207,9 @@ """Compare two Rats for inequality.""" return not self == other + # Silence Py3k warning + __hash__ = None + class RatTestCase(unittest.TestCase): """Unit tests for Rat class and its support utilities.""" Index: Lib/test/test_copy.py =================================================================== --- Lib/test/test_copy.py (revision 77350) +++ Lib/test/test_copy.py (working copy) @@ -661,7 +661,7 @@ v = copy.deepcopy(u) self.assertNotEqual(v, u) self.assertEqual(len(v), 2) - (x, y), (z, t) = sorted(v.items(), key=lambda (k, v): k.i) + (x, y), (z, t) = sorted(v.items(), key=lambda k: k[0].i) self.assertFalse(x is a) self.assertEqual(x.i, a.i) self.assertTrue(y is b) Index: Lib/test/test_richcmp.py =================================================================== --- Lib/test/test_richcmp.py (revision 77350) +++ Lib/test/test_richcmp.py (working copy) @@ -2,6 +2,7 @@ import unittest from test import test_support +import warnings import operator @@ -330,7 +331,13 @@ self.assertIs(op(x, y), True) def test_main(): - test_support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest) + test_support.run_unittest(VectorTest, NumberTest, MiscTest, ListTest) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "dict inequality comparisons " + "not supported in 3.x", DeprecationWarning) + test_support.run_unittest(DictTest) + if __name__ == "__main__": test_main() Index: Lib/test/test_multiprocessing.py =================================================================== --- Lib/test/test_multiprocessing.py (revision 77350) +++ Lib/test/test_multiprocessing.py (working copy) @@ -19,6 +19,7 @@ import logging from test import test_support from StringIO import StringIO +import warnings _multiprocessing = test_support.import_module('_multiprocessing') @@ -1991,7 +1992,11 @@ loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase suite = unittest.TestSuite(loadTestsFromTestCase(tc) for tc in testcases) - run(suite) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", ".+slice__ has been removed", + DeprecationWarning) + run(suite) ThreadsMixin.pool.terminate() ProcessesMixin.pool.terminate() Index: Lib/test/test_urllib.py =================================================================== --- Lib/test/test_urllib.py (revision 77350) +++ Lib/test/test_urllib.py (working copy) @@ -6,6 +6,7 @@ from test import test_support import os import mimetools +import random import tempfile import StringIO @@ -409,6 +410,13 @@ self.assertEqual(urllib.quote_plus('alpha+beta gamma', '+'), 'alpha+beta+gamma') + def test_quote_leak(self): + # bug 5596 - highlight the refleak in the internal _safemaps cache + safe = ''.join(chr(random.randrange(128)) for i in '123456') + text = 'abcdefghijklmnopqrstuvwxyz' + result = urllib.quote(text, safe=safe) + self.assertEqual(result, text) + class UnquotingTests(unittest.TestCase): """Tests for unquote() and unquote_plus() Index: Lib/test/test_mailbox.py =================================================================== --- Lib/test/test_mailbox.py (revision 77350) +++ Lib/test/test_mailbox.py (working copy) @@ -5,7 +5,6 @@ import socket import email import email.message -import rfc822 import re import StringIO from test import test_support @@ -17,6 +16,8 @@ except ImportError: pass +# Silence Py3k warning +rfc822 = test_support.import_module('rfc822') class TestBase(unittest.TestCase): Index: Lib/test/test_bigmem.py =================================================================== --- Lib/test/test_bigmem.py (revision 77350) +++ Lib/test/test_bigmem.py (working copy) @@ -97,21 +97,21 @@ def test_encode(self, size): return self.basic_encode_test(size, 'utf-8') - @precisionbigmemtest(size=_4G / 6 + 2, memuse=2) + @precisionbigmemtest(size=_4G // 6 + 2, memuse=2) def test_encode_raw_unicode_escape(self, size): try: return self.basic_encode_test(size, 'raw_unicode_escape') except MemoryError: pass # acceptable on 32-bit - @precisionbigmemtest(size=_4G / 5 + 70, memuse=3) + @precisionbigmemtest(size=_4G // 5 + 70, memuse=3) def test_encode_utf7(self, size): try: return self.basic_encode_test(size, 'utf7') except MemoryError: pass # acceptable on 32-bit - @precisionbigmemtest(size=_4G / 4 + 5, memuse=6) + @precisionbigmemtest(size=_4G // 4 + 5, memuse=6) def test_encode_utf32(self, size): try: return self.basic_encode_test(size, 'utf32', expectedsize=4*size+4) @@ -122,7 +122,7 @@ def test_decodeascii(self, size): return self.basic_encode_test(size, 'ascii', c='A') - @precisionbigmemtest(size=_4G / 5, memuse=6+2) + @precisionbigmemtest(size=_4G // 5, memuse=6+2) def test_unicode_repr_oflw(self, size): try: s = u"\uAAAA"*size @@ -516,7 +516,7 @@ self.assertEquals(s.count('\\'), size) self.assertEquals(s.count('0'), size * 2) - @bigmemtest(minsize=2**32 / 5, memuse=6+2) + @bigmemtest(minsize=2**32 // 5, memuse=6+2) def test_unicode_repr(self, size): s = u"\uAAAA" * size self.assertTrue(len(repr(s)) > size) @@ -1053,7 +1053,9 @@ @precisionbigmemtest(size=_1G, memuse=4) def test_repeat(self, size): try: - b = buffer("AAAA")*size + # Silence Py3k warning + with test_support.check_warnings(): + b = buffer("AAAA")*size except MemoryError: pass # acceptable on 32-bit else: Index: Lib/test/test_coercion.py =================================================================== --- Lib/test/test_coercion.py (revision 77350) +++ Lib/test/test_coercion.py (working copy) @@ -223,8 +223,11 @@ infix_results[key] = res - -process_infix_results() +with warnings.catch_warnings(): + # Silence Py3k warning + 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 +340,14 @@ 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(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", + "complex divmod.., // and % are deprecated", + DeprecationWarning) + warnings.filterwarnings("ignore", "classic .+ division", + DeprecationWarning) + run_unittest(CoercionTest) if __name__ == "__main__": test_main() Index: Lib/test/test_class.py =================================================================== --- Lib/test/test_class.py (revision 77350) +++ Lib/test/test_class.py (working copy) @@ -1,7 +1,7 @@ "Test the functionality of Python classes implementing operators." import unittest - +import warnings from test import test_support testmeths = [ @@ -407,7 +407,7 @@ self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))]) callLst[:] = [] - testme <> 1 # XXX kill this in py3k + eval('testme <> 1') # XXX kill this in py3k self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))]) callLst[:] = [] @@ -427,7 +427,7 @@ self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))]) callLst[:] = [] - 1 <> testme + eval('1 <> testme') self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))]) callLst[:] = [] @@ -616,7 +616,15 @@ hash(a.f) def test_main(): - test_support.run_unittest(ClassTests) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", ".+slice__ has been removed", + DeprecationWarning) + warnings.filterwarnings("ignore", "classic int division", + DeprecationWarning) + warnings.filterwarnings("ignore", "<> not supported", + DeprecationWarning) + test_support.run_unittest(ClassTests) if __name__=='__main__': test_main() Index: Lib/test/test_augassign.py =================================================================== --- Lib/test/test_augassign.py (revision 77350) +++ Lib/test/test_augassign.py (working copy) @@ -2,6 +2,7 @@ from test.test_support import run_unittest import unittest +import warnings class AugAssignTest(unittest.TestCase): @@ -324,7 +325,11 @@ '''.splitlines()) def test_main(): - run_unittest(AugAssignTest) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "classic int division", + DeprecationWarning) + run_unittest(AugAssignTest) if __name__ == '__main__': test_main() Index: Lib/test/test_userdict.py =================================================================== --- Lib/test/test_userdict.py (revision 77350) +++ Lib/test/test_userdict.py (working copy) @@ -45,7 +45,9 @@ # Test __repr__ self.assertEqual(str(u0), str(d0)) self.assertEqual(repr(u1), repr(d1)) - self.assertEqual(`u2`, `d2`) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertEqual(eval('`u2`'), eval('`d2`')) # Test __cmp__ and __len__ all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2] @@ -95,12 +97,14 @@ # Test has_key and "in". for i in u2.keys(): - self.assertTrue(u2.has_key(i)) self.assertTrue(i in u2) - self.assertEqual(u1.has_key(i), d1.has_key(i)) self.assertEqual(i in u1, i in d1) - self.assertEqual(u0.has_key(i), d0.has_key(i)) self.assertEqual(i in u0, i in d0) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertTrue(u2.has_key(i)) + self.assertEqual(u1.has_key(i), d1.has_key(i)) + self.assertEqual(u0.has_key(i), d0.has_key(i)) # Test update t = UserDict.UserDict() Index: Lib/test/test_trace.py =================================================================== --- Lib/test/test_trace.py (revision 77350) +++ Lib/test/test_trace.py (working copy) @@ -401,7 +401,7 @@ we're testing, so that the 'exception' trace event fires.""" if self.raiseOnEvent == 'exception': x = 0 - y = 1/x + y = 1 // x else: return 1 Index: Lib/test/test_userstring.py =================================================================== --- Lib/test/test_userstring.py (revision 77350) +++ Lib/test/test_userstring.py (working copy) @@ -136,8 +136,11 @@ def test_main(): with warnings.catch_warnings(): + # Silence Py3k warnings warnings.filterwarnings("ignore", ".*MutableString", DeprecationWarning) + warnings.filterwarnings("ignore", ".+slice__ has been removed", + DeprecationWarning) test_support.run_unittest(UserStringTest, MutableStringTest) if __name__ == "__main__": Index: Lib/test/test_builtin.py =================================================================== --- Lib/test/test_builtin.py (revision 77350) +++ Lib/test/test_builtin.py (working copy) @@ -7,10 +7,6 @@ from operator import neg import sys, warnings, cStringIO, random, fractions, UserDict -warnings.filterwarnings("ignore", "hex../oct.. of negative int", - FutureWarning, __name__) -warnings.filterwarnings("ignore", "integer argument expected", - DeprecationWarning, "unittest") # count the number of test runs. # used to skip running test_execfile() multiple times @@ -419,7 +415,11 @@ f.write('z = z+1\n') f.write('z = z*2\n') f.close() - execfile(TESTFN) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", ".+ not supported in 3.x", + DeprecationWarning) + execfile(TESTFN) def test_execfile(self): global numruns @@ -1542,17 +1542,30 @@ data = 'The quick Brown fox Jumped over The lazy Dog'.split() self.assertRaises(TypeError, sorted, data, None, lambda x,y: 0) +def _run_unittest(*args): + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", ".+ not supported in 3.x", + DeprecationWarning) + warnings.filterwarnings("ignore", ".+ is renamed to imp.reload", + DeprecationWarning) + warnings.filterwarnings("ignore", "integer argument expected, got float", + DeprecationWarning) + warnings.filterwarnings("ignore", "classic int division", + DeprecationWarning) + run_unittest(*args) + def test_main(verbose=None): test_classes = (BuiltinTest, TestSorted) - run_unittest(*test_classes) + _run_unittest(*test_classes) # verify reference counting if verbose and hasattr(sys, "gettotalrefcount"): import gc counts = [None] * 5 for i in xrange(len(counts)): - run_unittest(*test_classes) + _run_unittest(*test_classes) gc.collect() counts[i] = sys.gettotalrefcount() print counts Index: Lib/test/test_multibytecodec_support.py =================================================================== --- Lib/test/test_multibytecodec_support.py (revision 77350) +++ Lib/test/test_multibytecodec_support.py (working copy) @@ -307,7 +307,7 @@ continue unich = unichrs(data[1]) - if ord(unich) == 0xfffd or urt_wa.has_key(unich): + if ord(unich) == 0xfffd or unich in urt_wa: continue urt_wa[unich] = csetch Index: Lib/test/test_userlist.py =================================================================== --- Lib/test/test_userlist.py (revision 77350) +++ Lib/test/test_userlist.py (working copy) @@ -2,6 +2,7 @@ from UserList import UserList from test import test_support, list_tests +import warnings class UserListTest(list_tests.CommonTest): type2test = UserList @@ -53,7 +54,11 @@ self.assertEqual(iter(T((1,2))).next(), "0!!!") def test_main(): - test_support.run_unittest(UserListTest) + with warnings.catch_warnings(): + # Silence Py3k warnings + warnings.filterwarnings("ignore", ".+slice__ has been removed", + DeprecationWarning) + test_support.run_unittest(UserListTest) if __name__ == "__main__": test_main() Index: Lib/test/test_call.py =================================================================== --- Lib/test/test_call.py (revision 77350) +++ Lib/test/test_call.py (working copy) @@ -12,7 +12,9 @@ self.assertRaises(TypeError, {}.has_key) def test_varargs1(self): - {}.has_key(0) + # Silence Py3k warning + with test_support.check_warnings(): + {}.has_key(0) def test_varargs2(self): self.assertRaises(TypeError, {}.has_key, 0, 1) @@ -24,11 +26,15 @@ pass def test_varargs1_ext(self): - {}.has_key(*(0,)) + # Silence Py3k warning + with test_support.check_warnings(): + {}.has_key(*(0,)) def test_varargs2_ext(self): try: - {}.has_key(*(1, 2)) + # Silence Py3k warning + with test_support.check_warnings(): + {}.has_key(*(1, 2)) except TypeError: pass else: Index: Lib/test/test_collections.py =================================================================== --- Lib/test/test_collections.py (revision 77350) +++ Lib/test/test_collections.py (working copy) @@ -510,8 +510,10 @@ [('a', 3), ('b', 2), ('c', 1)]) self.assertEqual(c['b'], 2) self.assertEqual(c['z'], 0) - self.assertEqual(c.has_key('c'), True) - self.assertEqual(c.has_key('z'), False) + # Silence Py3k warning + with test_support.check_warnings(): + self.assertEqual(c.has_key('c'), True) + self.assertEqual(c.has_key('z'), False) self.assertEqual(c.__contains__('c'), True) self.assertEqual(c.__contains__('z'), False) self.assertEqual(c.get('b', 10), 2) Index: Lib/test/test_sys.py =================================================================== --- Lib/test/test_sys.py (revision 77350) +++ Lib/test/test_sys.py (working copy) @@ -68,7 +68,9 @@ # Python/pythonrun.c::PyErr_PrintEx() is tricky. def test_exc_clear(self): - self.assertRaises(TypeError, sys.exc_clear, 42) + # Silence Py3k warning + with test.test_support.check_warnings(): + self.assertRaises(TypeError, sys.exc_clear, 42) # Verify that exc_info is present and matches exc, then clear it, and # check that it worked. @@ -78,7 +80,9 @@ self.assertTrue(value is exc) self.assertTrue(traceback is not None) - sys.exc_clear() + # Silence Py3k warning + with test.test_support.check_warnings(): + sys.exc_clear() typ, value, traceback = sys.exc_info() self.assertTrue(typ is None) @@ -484,7 +488,9 @@ # bool check(True, size(h + 'l')) # buffer - check(buffer(''), size(h + '2P2Pil')) + # Silence Py3k warning + with test.test_support.check_warnings(): + check(buffer(''), size(h + '2P2Pil')) # builtin_function_or_method check(len, size(h + '3P')) # bytearray Index: Lib/test/test_ast.py =================================================================== --- Lib/test/test_ast.py (revision 77350) +++ Lib/test/test_ast.py (working copy) @@ -1,6 +1,7 @@ import sys, itertools, unittest from test import test_support import ast +import warnings def to_tuple(t): if t is None or isinstance(t, (basestring, int, long, complex)): @@ -302,7 +303,11 @@ def test_main(): - test_support.run_unittest(AST_Tests, ASTHelpers_Test) + with warnings.catch_warnings(): + # Silence Py3k warning + warnings.filterwarnings("ignore", "backquote not supported", + SyntaxWarning) + test_support.run_unittest(AST_Tests, ASTHelpers_Test) def main(): if __name__ != '__main__':