Fixing - Issue7026 - RuntimeError: dictionary changed size during iteration. Patch by flox

107 files changed, 800 insertions, 442 deletions

diff --git a/Lib/test/infinite_reload.py b/Lib/test/infinite_reload.py
index bfbec91..841ccad 100644
--- a/Lib/test/infinite_reload.py
+++ b/Lib/test/infinite_reload.py
@@ -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)
diff --git a/Lib/test/inspect_fodder.py b/Lib/test/inspect_fodder.py
index 823559b..afde2e2 100644
--- a/Lib/test/inspect_fodder.py
+++ b/Lib/test/inspect_fodder.py
@@ -15,7 +15,7 @@ def eggs(x, y):
     fr = inspect.currentframe()
     st = inspect.stack()
     p = x
-    q = y / 0
+    q = y // 0
 
 # line 20
 class StupidGit:
diff --git a/Lib/test/list_tests.py b/Lib/test/list_tests.py
index c9aa316..4fc99e0 100644
--- a/Lib/test/list_tests.py
+++ b/Lib/test/list_tests.py
@@ -4,7 +4,7 @@ Tests common to list and UserList.UserList
 
 import sys
 import os
-
+import warnings
 from test import test_support, seq_tests
 
 class CommonTest(seq_tests.CommonTest):
@@ -36,7 +36,9 @@ class CommonTest(seq_tests.CommonTest):
 
         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 @@ class CommonTest(seq_tests.CommonTest):
         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])
diff --git a/Lib/test/mapping_tests.py b/Lib/test/mapping_tests.py
index 7ec4bb1..d17c948 100644
--- a/Lib/test/mapping_tests.py
+++ b/Lib/test/mapping_tests.py
@@ -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 @@ class BasicTestMappingProtocol(unittest.TestCase):
         #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)
diff --git a/Lib/test/regrtest.py b/Lib/test/regrtest.py
index fd6cafc..56c53da 100755
--- a/Lib/test/regrtest.py
+++ b/Lib/test/regrtest.py
@@ -150,7 +150,6 @@ option '-uall,-bsddb'.
 import cStringIO
 import getopt
 import itertools
-import json
 import os
 import random
 import re
@@ -160,15 +159,13 @@ import traceback
 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 <string>, because for 64-bit platforms,
-    # that's where test_grammar.py hides them.
-    warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
-                            "<string>")
+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/)
diff --git a/Lib/test/seq_tests.py b/Lib/test/seq_tests.py
index 14303aa..f6b15bf 100644
--- a/Lib/test/seq_tests.py
+++ b/Lib/test/seq_tests.py
@@ -4,6 +4,7 @@ Tests common to tuple, list and UserList.UserList
 
 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 @@ class CommonTest(unittest.TestCase):
         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])
diff --git a/Lib/test/test_StringIO.py b/Lib/test/test_StringIO.py
index d10255d..e484f79 100644
--- a/Lib/test/test_StringIO.py
+++ b/Lib/test/test_StringIO.py
@@ -137,12 +137,10 @@ class TestBuffercStringIO(TestcStringIO):
 
 
 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()
diff --git a/Lib/test/test_anydbm.py b/Lib/test/test_anydbm.py
index 0cdc2c3..a01dd0b 100644
--- a/Lib/test/test_anydbm.py
+++ b/Lib/test/test_anydbm.py
@@ -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
diff --git a/Lib/test/test_array.py b/Lib/test/test_array.py
index 63f7083..004501a 100755
--- a/Lib/test/test_array.py
+++ b/Lib/test/test_array.py
@@ -749,7 +749,9 @@ class BaseTest(unittest.TestCase):
 
     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):
diff --git a/Lib/test/test_ast.py b/Lib/test/test_ast.py
index e592032..f16da15 100644
--- a/Lib/test/test_ast.py
+++ b/Lib/test/test_ast.py
@@ -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 @@ class ASTHelpers_Test(unittest.TestCase):
 
 
 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__':
diff --git a/Lib/test/test_augassign.py b/Lib/test/test_augassign.py
index a5b7cc4..51db28b 100644
--- a/Lib/test/test_augassign.py
+++ b/Lib/test/test_augassign.py
@@ -2,6 +2,7 @@
 
 from test.test_support import run_unittest
 import unittest
+import warnings
 
 
 class AugAssignTest(unittest.TestCase):
@@ -324,7 +325,11 @@ __ilshift__ called
 '''.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()
diff --git a/Lib/test/test_bigmem.py b/Lib/test/test_bigmem.py
index cb1b2f5..a3adaf3 100644
--- a/Lib/test/test_bigmem.py
+++ b/Lib/test/test_bigmem.py
@@ -97,21 +97,21 @@ class StrTest(unittest.TestCase):
     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 @@ class StrTest(unittest.TestCase):
     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 @@ class StrTest(unittest.TestCase):
         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 @@ class BufferTest(unittest.TestCase):
     @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:
diff --git a/Lib/test/test_binascii.py b/Lib/test/test_binascii.py
index c531c65..6a1f972 100755
--- a/Lib/test/test_binascii.py
+++ b/Lib/test/test_binascii.py
@@ -26,10 +26,10 @@ class BinASCIITest(unittest.TestCase):
                 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):
diff --git a/Lib/test/test_binop.py b/Lib/test/test_binop.py
index 8ae8f42..b1ef626 100644
--- a/Lib/test/test_binop.py
+++ b/Lib/test/test_binop.py
@@ -207,6 +207,9 @@ class Rat(object):
         """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."""
 
diff --git a/Lib/test/test_bool.py b/Lib/test/test_bool.py
index 2a9ef5d..805d758 100644
--- a/Lib/test/test_bool.py
+++ b/Lib/test/test_bool.py
@@ -91,10 +91,10 @@ class BoolTest(unittest.TestCase):
         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 @@ class BoolTest(unittest.TestCase):
         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 @@ class BoolTest(unittest.TestCase):
         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 @@ class BoolTest(unittest.TestCase):
         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)
diff --git a/Lib/test/test_buffer.py b/Lib/test/test_buffer.py
index 3bede88..ac89e05 100644
--- a/Lib/test/test_buffer.py
+++ b/Lib/test/test_buffer.py
@@ -6,6 +6,7 @@ For now, tests just new or changed functionality.
 
 import unittest
 from test import test_support
+import warnings
 
 class BufferTests(unittest.TestCase):
 
@@ -23,7 +24,11 @@ class BufferTests(unittest.TestCase):
 
 
 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()
diff --git a/Lib/test/test_builtin.py b/Lib/test/test_builtin.py
index f20d543..ac5b754 100644
--- a/Lib/test/test_builtin.py
+++ b/Lib/test/test_builtin.py
@@ -7,10 +7,6 @@ from test.test_support import fcmp, have_unicode, TESTFN, unlink, \
 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 @@ class BuiltinTest(unittest.TestCase):
     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 @@ class TestSorted(unittest.TestCase):
         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
diff --git a/Lib/test/test_call.py b/Lib/test/test_call.py
index f3c7c8c..3bbc081 100644
--- a/Lib/test/test_call.py
+++ b/Lib/test/test_call.py
@@ -12,7 +12,9 @@ class CFunctionCalls(unittest.TestCase):
         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 @@ class CFunctionCalls(unittest.TestCase):
             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:
diff --git a/Lib/test/test_capi.py b/Lib/test/test_capi.py
index 4dc3104..c313dcf 100644
--- a/Lib/test/test_capi.py
+++ b/Lib/test/test_capi.py
@@ -55,7 +55,7 @@ class TestPendingCalls(unittest.TestCase):
         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()
diff --git a/Lib/test/test_cgi.py b/Lib/test/test_cgi.py
index aa26bb6..44ebe10 100644
--- a/Lib/test/test_cgi.py
+++ b/Lib/test/test_cgi.py
@@ -104,7 +104,7 @@ parse_strict_test_cases = [
 
 def norm(list):
     if type(list) == type([]):
-        list.sort()
+        list.sort(key=str)
     return list
 
 def first_elts(list):
diff --git a/Lib/test/test_class.py b/Lib/test/test_class.py
index fc61d21..194b473 100644
--- a/Lib/test/test_class.py
+++ b/Lib/test/test_class.py
@@ -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 @@ class ClassTests(unittest.TestCase):
         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 @@ class ClassTests(unittest.TestCase):
         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 @@ class ClassTests(unittest.TestCase):
         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()
diff --git a/Lib/test/test_coercion.py b/Lib/test/test_coercion.py
index 67d19a6..c6a1c17 100644
--- a/Lib/test/test_coercion.py
+++ b/Lib/test/test_coercion.py
@@ -223,8 +223,11 @@ def process_infix_results():
             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 @@ class CoercionTest(unittest.TestCase):
             raise exc
 
 def test_main():
-    warnings.filterwarnings("ignore",
-                            r'complex divmod\(\), // and % are deprecated',
-                            DeprecationWarning,
-                            r'test.test_coercion$')
-    run_unittest(CoercionTest)
+    with warnings.catch_warnings():
+        # 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()
diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py
index fb24d43..b44beab 100644
--- a/Lib/test/test_collections.py
+++ b/Lib/test/test_collections.py
@@ -510,8 +510,10 @@ class TestCounter(unittest.TestCase):
                          [('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)
diff --git a/Lib/test/test_commands.py b/Lib/test/test_commands.py
index fcfa616..27b6c3d 100644
--- a/Lib/test/test_commands.py
+++ b/Lib/test/test_commands.py
@@ -9,7 +9,10 @@ import warnings
 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:
diff --git a/Lib/test/test_compile.py b/Lib/test/test_compile.py
index 28b7332..efc54e5 100644
--- a/Lib/test/test_compile.py
+++ b/Lib/test/test_compile.py
@@ -2,6 +2,7 @@ import unittest
 import sys
 import _ast
 from test import test_support
+import textwrap
 
 class TestSpecifics(unittest.TestCase):
 
@@ -141,7 +142,9 @@ def f(x):
         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 @@ def f(x):
             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:
diff --git a/Lib/test/test_compiler.py b/Lib/test/test_compiler.py
index 24930f8..a345ce6 100644
--- a/Lib/test/test_compiler.py
+++ b/Lib/test/test_compiler.py
@@ -75,7 +75,7 @@ class CompilerTest(unittest.TestCase):
 
     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",
                              "<string>", "exec")
         dct = {}
         exec c in dct
diff --git a/Lib/test/test_complex_args.py b/Lib/test/test_complex_args.py
index c6d50a9..f6950a7 100644
--- a/Lib/test/test_complex_args.py
+++ b/Lib/test/test_complex_args.py
@@ -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 @@ class ComplexArgsTestCase(unittest.TestCase):
         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 @@ class ComplexArgsTestCase(unittest.TestCase):
 
         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 @@ class ComplexArgsTestCase(unittest.TestCase):
         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 @@ class ComplexArgsTestCase(unittest.TestCase):
 
         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()
diff --git a/Lib/test/test_copy.py b/Lib/test/test_copy.py
index 823e9b3..bbe31d8 100644
--- a/Lib/test/test_copy.py
+++ b/Lib/test/test_copy.py
@@ -661,7 +661,7 @@ class TestCopy(unittest.TestCase):
         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)
diff --git a/Lib/test/test_ctypes.py b/Lib/test/test_ctypes.py
index 85f137e..4e93c87 100644
--- a/Lib/test/test_ctypes.py
+++ b/Lib/test/test_ctypes.py
@@ -4,12 +4,19 @@ from test.test_support import run_unittest, import_module
 #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()
diff --git a/Lib/test/test_decimal.py b/Lib/test/test_decimal.py
index 69f31a0..9fef0d2 100644
--- a/Lib/test/test_decimal.py
+++ b/Lib/test/test_decimal.py
@@ -31,7 +31,8 @@ import pickle, copy
 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 @@ class DecimalTest(unittest.TestCase):
         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 @@ class DecimalTest(unittest.TestCase):
         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 @@ class DecimalImplicitConstructionTest(unittest.TestCase):
             ('//', '__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 @@ class DecimalUsabilityTest(unittest.TestCase):
         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 @@ class ContextFlags(unittest.TestCase):
                 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: " +
diff --git a/Lib/test/test_descr.py b/Lib/test/test_descr.py
index 418337b..a044faf 100644
--- a/Lib/test/test_descr.py
+++ b/Lib/test/test_descr.py
@@ -4598,9 +4598,19 @@ class PTypesLongInitTest(unittest.TestCase):
 
 
 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()
diff --git a/Lib/test/test_descrtut.py b/Lib/test/test_descrtut.py
index c455e6b..157b9f4 100644
--- a/Lib/test/test_descrtut.py
+++ b/Lib/test/test_descrtut.py
@@ -66,7 +66,7 @@ dictionaries, such as the locals/globals dictionaries for the exec
 statement or the built-in function eval():
 
     >>> def sorted(seq):
-    ...     seq.sort()
+    ...     seq.sort(key=str)
     ...     return seq
     >>> print sorted(a.keys())
     [1, 2]
diff --git a/Lib/test/test_dict.py b/Lib/test/test_dict.py
index 075f9dc..de400aa 100644
--- a/Lib/test/test_dict.py
+++ b/Lib/test/test_dict.py
@@ -33,8 +33,12 @@ class DictTest(unittest.TestCase):
         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 @@ class DictTest(unittest.TestCase):
 
     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 @@ class DictTest(unittest.TestCase):
         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 @@ class DictTest(unittest.TestCase):
 
         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 @@ class DictTest(unittest.TestCase):
                      '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 @@ class DictTest(unittest.TestCase):
         # 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
diff --git a/Lib/test/test_exceptions.py b/Lib/test/test_exceptions.py
index a30f42b..7b63718 100644
--- a/Lib/test/test_exceptions.py
+++ b/Lib/test/test_exceptions.py
@@ -7,7 +7,7 @@ import pickle, cPickle
 import warnings
 
 from test.test_support import TESTFN, unlink, run_unittest, captured_output
-from test.test_pep352 import ignore_message_warning
+from test.test_pep352 import ignore_deprecation_warnings
 
 # XXX This is not really enough, each *operation* should be tested!
 
@@ -17,6 +17,7 @@ class ExceptionTests(unittest.TestCase):
         # Reloading the built-in exceptions module failed prior to Py2.2, while it
         # should act the same as reloading built-in sys.
         try:
+            from imp import reload
             import exceptions
             reload(exceptions)
         except ImportError, e:
@@ -108,11 +109,11 @@ class ExceptionTests(unittest.TestCase):
         self.assertRaises(ValueError, chr, 10000)
 
         self.raise_catch(ZeroDivisionError, "ZeroDivisionError")
-        try: x = 1/0
+        try: x = 1 // 0
         except ZeroDivisionError: pass
 
         self.raise_catch(Exception, "Exception")
-        try: x = 1/0
+        try: x = 1 // 0
         except Exception, e: pass
 
     def testSyntaxErrorMessage(self):
@@ -197,6 +198,7 @@ class ExceptionTests(unittest.TestCase):
             self.assertEqual(WindowsError(1001, "message").errno, 22)
             self.assertEqual(WindowsError(1001, "message").winerror, 1001)
 
+    @ignore_deprecation_warnings
     def testAttributes(self):
         # test that exception attributes are happy
 
@@ -274,34 +276,32 @@ class ExceptionTests(unittest.TestCase):
         except NameError:
             pass
 
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            for exc, args, expected in exceptionList:
-                try:
-                    raise exc(*args)
-                except BaseException, e:
-                    if type(e) is not exc:
-                        raise
-                    # Verify module name
-                    self.assertEquals(type(e).__module__, 'exceptions')
-                    # Verify no ref leaks in Exc_str()
-                    s = str(e)
-                    for checkArgName in expected:
-                        self.assertEquals(repr(getattr(e, checkArgName)),
-                                          repr(expected[checkArgName]),
-                                          'exception "%s", attribute "%s"' %
-                                           (repr(e), checkArgName))
-
-                    # test for pickling support
-                    for p in pickle, cPickle:
-                        for protocol in range(p.HIGHEST_PROTOCOL + 1):
-                            new = p.loads(p.dumps(e, protocol))
-                            for checkArgName in expected:
-                                got = repr(getattr(new, checkArgName))
-                                want = repr(expected[checkArgName])
-                                self.assertEquals(got, want,
-                                                  'pickled "%r", attribute "%s"' %
-                                                  (e, checkArgName))
+        for exc, args, expected in exceptionList:
+            try:
+                raise exc(*args)
+            except BaseException, e:
+                if type(e) is not exc:
+                    raise
+                # Verify module name
+                self.assertEquals(type(e).__module__, 'exceptions')
+                # Verify no ref leaks in Exc_str()
+                s = str(e)
+                for checkArgName in expected:
+                    self.assertEquals(repr(getattr(e, checkArgName)),
+                                      repr(expected[checkArgName]),
+                                      'exception "%s", attribute "%s"' %
+                                       (repr(e), checkArgName))
+
+                # test for pickling support
+                for p in pickle, cPickle:
+                    for protocol in range(p.HIGHEST_PROTOCOL + 1):
+                        new = p.loads(p.dumps(e, protocol))
+                        for checkArgName in expected:
+                            got = repr(getattr(new, checkArgName))
+                            want = repr(expected[checkArgName])
+                            self.assertEquals(got, want,
+                                              'pickled "%r", attribute "%s"' %
+                                              (e, checkArgName))
 
 
     def testDeprecatedMessageAttribute(self):
@@ -330,6 +330,7 @@ class ExceptionTests(unittest.TestCase):
         with self.assertRaises(AttributeError):
             exc.message
 
+    @ignore_deprecation_warnings
     def testPickleMessageAttribute(self):
         # Pickling with message attribute must work, as well.
         e = Exception("foo")
@@ -337,9 +338,7 @@ class ExceptionTests(unittest.TestCase):
         f.message = "bar"
         for p in pickle, cPickle:
             ep = p.loads(p.dumps(e))
-            with warnings.catch_warnings():
-                ignore_message_warning()
-                self.assertEqual(ep.message, "foo")
+            self.assertEqual(ep.message, "foo")
             fp = p.loads(p.dumps(f))
             self.assertEqual(fp.message, "bar")
 
@@ -348,7 +347,12 @@ class ExceptionTests(unittest.TestCase):
         # going through the 'args' attribute.
         args = (1, 2, 3)
         exc = BaseException(*args)
-        self.assertEqual(exc[:], args)
+        self.assertEqual(exc.args[:], args)
+        with warnings.catch_warnings():
+            # Silence Py3k warning
+            warnings.filterwarnings("ignore", "__getslice__ not supported for "
+                                    "exception classes", DeprecationWarning)
+            self.assertEqual(exc[:], args)
 
     def testKeywordArgs(self):
         # test that builtin exception don't take keyword args,
diff --git a/Lib/test/test_file.py b/Lib/test/test_file.py
index 7d3e72d..a91897e 100644
--- a/Lib/test/test_file.py
+++ b/Lib/test/test_file.py
@@ -127,7 +127,7 @@ class AutoFileTests(unittest.TestCase):
         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)
 
diff --git a/Lib/test/test_file2k.py b/Lib/test/test_file2k.py
index bf47c6f..bebc43d 100644
--- a/Lib/test/test_file2k.py
+++ b/Lib/test/test_file2k.py
@@ -34,13 +34,17 @@ class AutoFileTests(unittest.TestCase):
     def testAttributes(self):
         # verify expected attributes exist
         f = self.f
-        softspace = f.softspace
+        # Silence Py3k warning
+        with test_support.check_warnings():
+            softspace = f.softspace
         f.name     # merely shouldn't blow up
         f.mode     # ditto
         f.closed   # ditto
 
-        # verify softspace is writable
-        f.softspace = softspace    # merely shouldn't blow up
+        # Silence Py3k warning
+        with test_support.check_warnings():
+            # verify softspace is writable
+            f.softspace = softspace    # merely shouldn't blow up
 
         # verify the others aren't
         for attr in 'name', 'mode', 'closed':
@@ -98,7 +102,8 @@ class AutoFileTests(unittest.TestCase):
     def testMethods(self):
         methods = ['fileno', 'flush', 'isatty', 'next', 'read', 'readinto',
                    'readline', 'readlines', 'seek', 'tell', 'truncate',
-                   'write', 'xreadlines', '__iter__']
+                   'write', '__iter__']
+        deprecated_methods = ['xreadlines']
         if sys.platform.startswith('atheos'):
             methods.remove('truncate')
 
@@ -110,13 +115,18 @@ class AutoFileTests(unittest.TestCase):
             method = getattr(self.f, methodname)
             # should raise on closed file
             self.assertRaises(ValueError, method)
+        # Silence Py3k warning
+        with test_support.check_warnings():
+            for methodname in deprecated_methods:
+                method = getattr(self.f, methodname)
+                self.assertRaises(ValueError, method)
         self.assertRaises(ValueError, self.f.writelines, [])
 
         # file is closed, __exit__ shouldn't do anything
         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)
 
@@ -182,12 +192,12 @@ class OtherFileTests(unittest.TestCase):
         try:
             f = open(TESTFN, bad_mode)
         except ValueError, msg:
-            if msg[0] != 0:
+            if msg.args[0] != 0:
                 s = str(msg)
                 if s.find(TESTFN) != -1 or s.find(bad_mode) == -1:
                     self.fail("bad error message for invalid mode: %s" % s)
-            # if msg[0] == 0, we're probably on Windows where there may be
-            # no obvious way to discover why open() failed.
+            # if msg.args[0] == 0, we're probably on Windows where there may
+            # be no obvious way to discover why open() failed.
         else:
             f.close()
             self.fail("no error for invalid mode: %s" % bad_mode)
diff --git a/Lib/test/test_fractions.py b/Lib/test/test_fractions.py
index de8e539..9e3fc5e 100644
--- a/Lib/test/test_fractions.py
+++ b/Lib/test/test_fractions.py
@@ -43,6 +43,10 @@ class DummyFloat(object):
         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 @@ class DummyRational(object):
     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):
diff --git a/Lib/test/test_ftplib.py b/Lib/test/test_ftplib.py
index fb9d55b..b391561 100644
--- a/Lib/test/test_ftplib.py
+++ b/Lib/test/test_ftplib.py
@@ -100,7 +100,7 @@ class DummyFTPHandler(asynchat.async_chat):
         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)
diff --git a/Lib/test/test_functools.py b/Lib/test/test_functools.py
index ab5bac2..aa672ab 100644
--- a/Lib/test/test_functools.py
+++ b/Lib/test/test_functools.py
@@ -116,7 +116,7 @@ class TestPartial(unittest.TestCase):
 
     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)
diff --git a/Lib/test/test_grammar.py b/Lib/test/test_grammar.py
index f144ae7..573a512 100644
--- a/Lib/test/test_grammar.py
+++ b/Lib/test/test_grammar.py
@@ -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 @@ class GrammarTests(unittest.TestCase):
         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 @@ class GrammarTests(unittest.TestCase):
         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 @@ class GrammarTests(unittest.TestCase):
         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 @@ hello world
                     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 @@ hello world
         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 @@ hello world
         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 @@ hello world
         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 @@ hello world
 
 
 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()
diff --git a/Lib/test/test_gzip.py b/Lib/test/test_gzip.py
index 60094dc..ed5aa96 100644
--- a/Lib/test/test_gzip.py
+++ b/Lib/test/test_gzip.py
@@ -246,11 +246,11 @@ class TestGzip(unittest.TestCase):
             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)
diff --git a/Lib/test/test_heapq.py b/Lib/test/test_heapq.py
index e377384..20eceed 100644
--- a/Lib/test/test_heapq.py
+++ b/Lib/test/test_heapq.py
@@ -356,7 +356,8 @@ class TestErrorHandling(unittest.TestCase):
         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))
diff --git a/Lib/test/test_hotshot.py b/Lib/test/test_hotshot.py
index 38a8ddd..c6dae36 100644
--- a/Lib/test/test_hotshot.py
+++ b/Lib/test/test_hotshot.py
@@ -1,5 +1,3 @@
-import hotshot
-import hotshot.log
 import os
 import pprint
 import unittest
@@ -9,6 +7,8 @@ import gc
 
 from test import test_support
 
+# Silence Py3k warning
+hotshot = test_support.import_module('hotshot', deprecated=True)
 from hotshot.log import ENTER, EXIT, LINE
 
 
diff --git a/Lib/test/test_import.py b/Lib/test/test_import.py
index 31375dc..5f54b57 100644
--- a/Lib/test/test_import.py
+++ b/Lib/test/test_import.py
@@ -7,6 +7,7 @@ import sys
 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 @@ class ImportTest(unittest.TestCase):
             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 @@ class ImportTest(unittest.TestCase):
                 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 @@ class ImportTest(unittest.TestCase):
     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
diff --git a/Lib/test/test_importhooks.py b/Lib/test/test_importhooks.py
index 7fd8c62..f3452fa 100644
--- a/Lib/test/test_importhooks.py
+++ b/Lib/test/test_importhooks.py
@@ -180,7 +180,7 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
         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 @@ class ImportHooksTestCase(ImportHooksBaseTestCase):
             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():
diff --git a/Lib/test/test_inspect.py b/Lib/test/test_inspect.py
index f20b26c..144fcf3 100644
--- a/Lib/test/test_inspect.py
+++ b/Lib/test/test_inspect.py
@@ -4,10 +4,11 @@ import unittest
 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 @@ if modfile.endswith(('c', 'o')):
 import __builtin__
 
 try:
-    1/0
+    1 // 0
 except:
     tb = sys.exc_traceback
 
@@ -167,7 +168,7 @@ class TestInterpreterStack(IsTestBase):
         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 @@ class TestClassesAndFunctions(unittest.TestCase):
         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:
diff --git a/Lib/test/test_io.py b/Lib/test/test_io.py
index a90dd50..48ffd45 100644
--- a/Lib/test/test_io.py
+++ b/Lib/test/test_io.py
@@ -381,11 +381,11 @@ class IOTest(unittest.TestCase):
             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):
diff --git a/Lib/test/test_iter.py b/Lib/test/test_iter.py
index f5d6e68..5e96c6d 100644
--- a/Lib/test/test_iter.py
+++ b/Lib/test/test_iter.py
@@ -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 @@ class TestCase(unittest.TestCase):
                 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 @@ class TestCase(unittest.TestCase):
                 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)
diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py
index 03f1d85..d69aecf 100644
--- a/Lib/test/test_itertools.py
+++ b/Lib/test/test_itertools.py
@@ -9,6 +9,7 @@ import operator
 import random
 import copy
 import pickle
+from functools import reduce
 maxsize = test_support.MAX_Py_ssize_t
 minsize = -maxsize-1
 
@@ -122,7 +123,7 @@ class TestBasicOps(unittest.TestCase):
             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 @@ class TestBasicOps(unittest.TestCase):
         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 @@ class TestBasicOps(unittest.TestCase):
             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 @@ class TestBasicOps(unittest.TestCase):
 
                 # 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 @@ class TestBasicOps(unittest.TestCase):
                 [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 @@ class TestBasicOps(unittest.TestCase):
         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 @@ Samuele
 # 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]
diff --git a/Lib/test/test_json.py b/Lib/test/test_json.py
index 7b8f3de..bb99dab 100644
--- a/Lib/test/test_json.py
+++ b/Lib/test/test_json.py
@@ -7,10 +7,15 @@ be run.
 
 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__":
diff --git a/Lib/test/test_linuxaudiodev.py b/Lib/test/test_linuxaudiodev.py
index 71d0633..3772a58 100644
--- a/Lib/test/test_linuxaudiodev.py
+++ b/Lib/test/test_linuxaudiodev.py
@@ -4,12 +4,13 @@ test_support.requires('audio')
 from test.test_support import findfile, run_unittest
 
 import errno
-linuxaudiodev = test_support.import_module('linuxaudiodev', deprecated=True)
 import sys
-import sunaudio
 import audioop
 import unittest
 
+linuxaudiodev = test_support.import_module('linuxaudiodev', deprecated=True)
+sunaudio = test_support.import_module('sunaudio', deprecated=True)
+
 SND_FORMAT_MULAW_8 = 1
 
 class LinuxAudioDevTests(unittest.TestCase):
diff --git a/Lib/test/test_long.py b/Lib/test/test_long.py
index 1943518..ad84589 100644
--- a/Lib/test/test_long.py
+++ b/Lib/test/test_long.py
@@ -575,11 +575,13 @@ class LongTest(unittest.TestCase):
             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 @@ class LongTest(unittest.TestCase):
                 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
diff --git a/Lib/test/test_mailbox.py b/Lib/test/test_mailbox.py
index 548850a..01b1c36 100644
--- a/Lib/test/test_mailbox.py
+++ b/Lib/test/test_mailbox.py
@@ -5,7 +5,6 @@ import stat
 import socket
 import email
 import email.message
-import rfc822
 import re
 import StringIO
 from test import test_support
@@ -17,6 +16,8 @@ try:
 except ImportError:
     pass
 
+# Silence Py3k warning
+rfc822 = test_support.import_module('rfc822')
 
 class TestBase(unittest.TestCase):
 
diff --git a/Lib/test/test_marshal.py b/Lib/test/test_marshal.py
index 7669182..af89d18 100644
--- a/Lib/test/test_marshal.py
+++ b/Lib/test/test_marshal.py
@@ -129,7 +129,9 @@ class StringTestCase(unittest.TestCase):
 
     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"))
diff --git a/Lib/test/test_multibytecodec_support.py b/Lib/test/test_multibytecodec_support.py
index 3afe3a9..36245b7 100644
--- a/Lib/test/test_multibytecodec_support.py
+++ b/Lib/test/test_multibytecodec_support.py
@@ -307,7 +307,7 @@ class TestBase_Mapping(unittest.TestCase):
                 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
 
diff --git a/Lib/test/test_multifile.py b/Lib/test/test_multifile.py
index daf7dde..fd09602 100644
--- a/Lib/test/test_multifile.py
+++ b/Lib/test/test_multifile.py
@@ -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
 
diff --git a/Lib/test/test_multiprocessing.py b/Lib/test/test_multiprocessing.py
index b6c6a84..94d4dd0 100644
--- a/Lib/test/test_multiprocessing.py
+++ b/Lib/test/test_multiprocessing.py
@@ -19,6 +19,7 @@ import random
 import logging
 from test import test_support
 from StringIO import StringIO
+import warnings
 
 
 _multiprocessing = test_support.import_module('_multiprocessing')
@@ -1991,7 +1992,11 @@ def test_main(run=None):
 
     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()
diff --git a/Lib/test/test_mutants.py b/Lib/test/test_mutants.py
index a219450..69c381e 100644
--- a/Lib/test/test_mutants.py
+++ b/Lib/test/test_mutants.py
@@ -210,7 +210,7 @@ class Machiavelli:
         # Tim sez:  "luck of the draw; crashes with or without for me."
         print >> f
 
-        return `"machiavelli"`
+        return repr("machiavelli")
 
     def __hash__(self):
         return 0
diff --git a/Lib/test/test_opcodes.py b/Lib/test/test_opcodes.py
index c03ca1d..6c9fd58 100644
--- a/Lib/test/test_opcodes.py
+++ b/Lib/test/test_opcodes.py
@@ -2,6 +2,7 @@
 
 from test.test_support import run_unittest
 import unittest
+import warnings
 
 class OpcodeTest(unittest.TestCase):
 
@@ -9,7 +10,7 @@ class OpcodeTest(unittest.TestCase):
         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 @@ class OpcodeTest(unittest.TestCase):
 
 
 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()
diff --git a/Lib/test/test_operator.py b/Lib/test/test_operator.py
index 2758856..70b9fd9 100644
--- a/Lib/test/test_operator.py
+++ b/Lib/test/test_operator.py
@@ -192,11 +192,12 @@ class OperatorTestCase(unittest.TestCase):
         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 @@ class OperatorTestCase(unittest.TestCase):
         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)
diff --git a/Lib/test/test_optparse.py b/Lib/test/test_optparse.py
index b11b8c9..f7eb47b 100644
--- a/Lib/test/test_optparse.py
+++ b/Lib/test/test_optparse.py
@@ -26,12 +26,6 @@ from optparse import make_option, Option, IndentedHelpFormatter, \
 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):
diff --git a/Lib/test/test_ossaudiodev.py b/Lib/test/test_ossaudiodev.py
index df04705..40903dc 100644
--- a/Lib/test/test_ossaudiodev.py
+++ b/Lib/test/test_ossaudiodev.py
@@ -71,7 +71,7 @@ class OSSAudioDevTests(unittest.TestCase):
                 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)
diff --git a/Lib/test/test_peepholer.py b/Lib/test/test_peepholer.py
index 1f6efb5..de8d1ea 100644
--- a/Lib/test/test_peepholer.py
+++ b/Lib/test/test_peepholer.py
@@ -205,18 +205,24 @@ class TestTranforms(unittest.TestCase):
 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)
diff --git a/Lib/test/test_pep352.py b/Lib/test/test_pep352.py
index c6d3a8d..103d835 100644
--- a/Lib/test/test_pep352.py
+++ b/Lib/test/test_pep352.py
@@ -6,12 +6,23 @@ from test.test_support import run_unittest
 import os
 from platform import system as platform_system
 
-def ignore_message_warning():
-    """Ignore the DeprecationWarning for BaseException.message."""
-    warnings.resetwarnings()
-    warnings.filterwarnings("ignore", "BaseException.message",
-                            DeprecationWarning)
-
+DEPRECATION_WARNINGS = (
+    "BaseException.message has been deprecated",
+    "exceptions must derive from BaseException",
+    "catching classes that don't inherit from BaseException is not allowed",
+    "__getitem__ not supported for exception classes",
+)
+
+# Silence Py3k and other deprecation warnings
+def ignore_deprecation_warnings(func):
+    """Ignore the known DeprecationWarnings."""
+    def wrapper(*args, **kw):
+        with warnings.catch_warnings():
+            warnings.resetwarnings()
+            for text in DEPRECATION_WARNINGS:
+                warnings.filterwarnings("ignore", text, DeprecationWarning)
+            return func(*args, **kw)
+    return wrapper
 
 class ExceptionClassTests(unittest.TestCase):
 
@@ -21,14 +32,12 @@ class ExceptionClassTests(unittest.TestCase):
     def test_builtins_new_style(self):
         self.assertTrue(issubclass(Exception, object))
 
+    @ignore_deprecation_warnings
     def verify_instance_interface(self, ins):
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            for attr in ("args", "message", "__str__", "__repr__",
-                            "__getitem__"):
-                self.assertTrue(hasattr(ins, attr),
-                        "%s missing %s attribute" %
-                            (ins.__class__.__name__, attr))
+        for attr in ("args", "message", "__str__", "__repr__", "__getitem__"):
+            self.assertTrue(hasattr(ins, attr),
+                    "%s missing %s attribute" %
+                        (ins.__class__.__name__, attr))
 
     def test_inheritance(self):
         # Make sure the inheritance hierarchy matches the documentation
@@ -91,43 +100,39 @@ class ExceptionClassTests(unittest.TestCase):
             self.assertEqual(given, expected, "%s: %s != %s" % (test_name,
                 given, expected))
 
+    @ignore_deprecation_warnings
     def test_interface_single_arg(self):
         # Make sure interface works properly when given a single argument
         arg = "spam"
         exc = Exception(arg)
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            results = ([len(exc.args), 1], [exc.args[0], arg],
-                    [exc.message, arg],
-                    [str(exc), str(arg)], [unicode(exc), unicode(arg)],
-                [repr(exc), exc.__class__.__name__ + repr(exc.args)], [exc[0],
-                arg])
-            self.interface_test_driver(results)
+        results = ([len(exc.args), 1], [exc.args[0], arg], [exc.message, arg],
+                   [str(exc), str(arg)], [unicode(exc), unicode(arg)],
+                   [repr(exc), exc.__class__.__name__ + repr(exc.args)],
+                   [exc[0], arg])
+        self.interface_test_driver(results)
 
+    @ignore_deprecation_warnings
     def test_interface_multi_arg(self):
         # Make sure interface correct when multiple arguments given
         arg_count = 3
         args = tuple(range(arg_count))
         exc = Exception(*args)
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            results = ([len(exc.args), arg_count], [exc.args, args],
-                    [exc.message, ''], [str(exc), str(args)],
-                    [unicode(exc), unicode(args)],
-                    [repr(exc), exc.__class__.__name__ + repr(exc.args)],
-                    [exc[-1], args[-1]])
-            self.interface_test_driver(results)
-
+        results = ([len(exc.args), arg_count], [exc.args, args],
+                   [exc.message, ''], [str(exc), str(args)],
+                   [unicode(exc), unicode(args)],
+                   [repr(exc), exc.__class__.__name__ + repr(exc.args)],
+                   [exc[-1], args[-1]])
+        self.interface_test_driver(results)
+
+    @ignore_deprecation_warnings
     def test_interface_no_arg(self):
         # Make sure that with no args that interface is correct
         exc = Exception()
-        with warnings.catch_warnings():
-            ignore_message_warning()
-            results = ([len(exc.args), 0], [exc.args, tuple()],
-                    [exc.message, ''],
-                    [str(exc), ''], [unicode(exc), u''],
-                    [repr(exc), exc.__class__.__name__ + '()'], [True, True])
-            self.interface_test_driver(results)
+        results = ([len(exc.args), 0], [exc.args, tuple()],
+                   [exc.message, ''],
+                   [str(exc), ''], [unicode(exc), u''],
+                   [repr(exc), exc.__class__.__name__ + '()'], [True, True])
+        self.interface_test_driver(results)
 
 
     def test_message_deprecation(self):
@@ -179,6 +184,7 @@ class UsageTests(unittest.TestCase):
             self.fail("TypeError expected when catching %s as specified in a "
                         "tuple" % type(object_))
 
+    @ignore_deprecation_warnings
     def test_raise_classic(self):
         # Raising a classic class is okay (for now).
         class ClassicClass:
diff --git a/Lib/test/test_pkgimport.py b/Lib/test/test_pkgimport.py
index 8aa224a..20b13c1 100644
--- a/Lib/test/test_pkgimport.py
+++ b/Lib/test/test_pkgimport.py
@@ -6,14 +6,14 @@ class TestImport(unittest.TestCase):
 
     def __init__(self, *args, **kw):
         self.package_name = 'PACKAGE_'
-        while sys.modules.has_key(self.package_name):
+        while self.package_name in sys.modules:
             self.package_name += random.choose(string.letters)
         self.module_name = self.package_name + '.foo'
         unittest.TestCase.__init__(self, *args, **kw)
 
     def remove_modules(self):
         for module_name in (self.package_name, self.module_name):
-            if sys.modules.has_key(module_name):
+            if module_name in sys.modules:
                 del sys.modules[module_name]
 
     def setUp(self):
@@ -52,7 +52,7 @@ class TestImport(unittest.TestCase):
         try: __import__(self.module_name)
         except SyntaxError: pass
         else: raise RuntimeError, 'Failed to induce SyntaxError'
-        self.assertTrue(not sys.modules.has_key(self.module_name) and
+        self.assertTrue(self.module_name not in sys.modules and
                      not hasattr(sys.modules[self.package_name], 'foo'))
 
         # ...make up a variable name that isn't bound in __builtins__
diff --git a/Lib/test/test_pyclbr.py b/Lib/test/test_pyclbr.py
index ec818d1..5bac62a 100644
--- a/Lib/test/test_pyclbr.py
+++ b/Lib/test/test_pyclbr.py
@@ -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 @@ ClassMethodType = type(classmethod(lambda c: None))
 
 # 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 @@ class PyclbrTest(TestCase):
 
 
     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 @@ class PyclbrTest(TestCase):
     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):
diff --git a/Lib/test/test_pyexpat.py b/Lib/test/test_pyexpat.py
index 649d5d2..ffd6875 100644
--- a/Lib/test/test_pyexpat.py
+++ b/Lib/test/test_pyexpat.py
@@ -554,7 +554,7 @@ class ChardataBufferTest(unittest.TestCase):
 
         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)
diff --git a/Lib/test/test_queue.py b/Lib/test/test_queue.py
index 2fa36b7..e6d2e69 100644
--- a/Lib/test/test_queue.py
+++ b/Lib/test/test_queue.py
@@ -7,7 +7,8 @@ import time
 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 @@ class BaseQueueTest(unittest.TestCase, BlockingTestMixin):
             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()
diff --git a/Lib/test/test_random.py b/Lib/test/test_random.py
index 14d0383..8d8c3c3 100644
--- a/Lib/test/test_random.py
+++ b/Lib/test/test_random.py
@@ -6,6 +6,7 @@ import time
 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):
diff --git a/Lib/test/test_repr.py b/Lib/test/test_repr.py
index 494a7c3..ef07075 100644
--- a/Lib/test/test_repr.py
+++ b/Lib/test/test_repr.py
@@ -8,7 +8,7 @@ import os
 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 @@ class ReprTests(unittest.TestCase):
     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('<read-only buffer for 0x'))
 
     def test_cell(self):
diff --git a/Lib/test/test_rfc822.py b/Lib/test/test_rfc822.py
index 8c2b2c6..d8a0280 100644
--- a/Lib/test/test_rfc822.py
+++ b/Lib/test/test_rfc822.py
@@ -46,9 +46,9 @@ class MessageTestCase(unittest.TestCase):
                 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:
diff --git a/Lib/test/test_richcmp.py b/Lib/test/test_richcmp.py
index ed0b497..47dcc70 100644
--- a/Lib/test/test_richcmp.py
+++ b/Lib/test/test_richcmp.py
@@ -2,6 +2,7 @@
 
 import unittest
 from test import test_support
+import warnings
 
 import operator
 
@@ -330,7 +331,13 @@ class ListTest(unittest.TestCase):
             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()
diff --git a/Lib/test/test_scope.py b/Lib/test/test_scope.py
index cf30ff9..6ff53b3 100644
--- a/Lib/test/test_scope.py
+++ b/Lib/test/test_scope.py
@@ -321,10 +321,16 @@ else:
 
         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 @@ self.assertTrue(X.passed)
             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})
 
diff --git a/Lib/test/test_set.py b/Lib/test/test_set.py
index bc7465a..8595368 100644
--- a/Lib/test/test_set.py
+++ b/Lib/test/test_set.py
@@ -1218,15 +1218,16 @@ class TestOnlySetsInBinaryOps(unittest.TestCase):
         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)
+        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)
+            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 @@ class TestCopying(unittest.TestCase):
 
     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 @@ class TestVariousIteratorArgs(unittest.TestCase):
         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 @@ class TestVariousIteratorArgs(unittest.TestCase):
                     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 @@ class TestVariousIteratorArgs(unittest.TestCase):
                     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))
diff --git a/Lib/test/test_sets.py b/Lib/test/test_sets.py
index 9c59836..754ceb1 100644
--- a/Lib/test/test_sets.py
+++ b/Lib/test/test_sets.py
@@ -510,15 +510,17 @@ class TestOnlySetsInBinaryOps(unittest.TestCase):
         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 @@ class TestCopying(unittest.TestCase):
 
     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)
 
 #------------------------------------------------------------------------------
 
diff --git a/Lib/test/test_shelve.py b/Lib/test/test_shelve.py
index ffcc98d..3b20281 100644
--- a/Lib/test/test_shelve.py
+++ b/Lib/test/test_shelve.py
@@ -4,6 +4,8 @@ import shelve
 import glob
 from test import test_support
 
+test_support.import_module('anydbm', deprecated=True)
+
 class TestCase(unittest.TestCase):
 
     fn = "shelftemp" + os.extsep + "db"
diff --git a/Lib/test/test_site.py b/Lib/test/test_site.py
index 56596c8..85d898a 100644
--- a/Lib/test/test_site.py
+++ b/Lib/test/test_site.py
@@ -258,7 +258,7 @@ class ImportSideEffectTests(unittest.TestCase):
         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 @@ class ImportSideEffectTests(unittest.TestCase):
 
     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:
diff --git a/Lib/test/test_slice.py b/Lib/test/test_slice.py
index 08de8e3..6aa3d4a 100644
--- a/Lib/test/test_slice.py
+++ b/Lib/test/test_slice.py
@@ -115,7 +115,9 @@ class SliceTest(unittest.TestCase):
                 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):
diff --git a/Lib/test/test_socket.py b/Lib/test/test_socket.py
index faa06c5..b4f37eb 100644
--- a/Lib/test/test_socket.py
+++ b/Lib/test/test_socket.py
@@ -123,7 +123,7 @@ class ThreadableTest:
         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 @@ class GeneralModuleTests(unittest.TestCase):
                 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 @@ class BufferIOTest(SocketConnectedTest):
         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 @@ class BufferIOTest(SocketConnectedTest):
         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)
 
 
diff --git a/Lib/test/test_sort.py b/Lib/test/test_sort.py
index a61fb96..a8e239a 100644
--- a/Lib/test/test_sort.py
+++ b/Lib/test/test_sort.py
@@ -2,6 +2,7 @@ from test import test_support
 import random
 import sys
 import unittest
+import warnings
 
 verbose = test_support.verbose
 nerrors = 0
@@ -185,7 +186,7 @@ class TestDecorateSortUndecorate(unittest.TestCase):
     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 @@ class TestDecorateSortUndecorate(unittest.TestCase):
         # 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 @@ def test_main(verbose=None):
         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)
diff --git a/Lib/test/test_sqlite.py b/Lib/test/test_sqlite.py
index 167408c..f3bfd3e 100644
--- a/Lib/test/test_sqlite.py
+++ b/Lib/test/test_sqlite.py
@@ -4,14 +4,21 @@ from test.test_support import run_unittest, import_module
 # 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()
diff --git a/Lib/test/test_ssl.py b/Lib/test/test_ssl.py
index 5aca135..4ba2e2a 100644
--- a/Lib/test/test_ssl.py
+++ b/Lib/test/test_ssl.py
@@ -808,7 +808,7 @@ else:
                     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 @@ else:
                 # 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))
diff --git a/Lib/test/test_struct.py b/Lib/test/test_struct.py
index 556a576..76a29cd 100644
--- a/Lib/test/test_struct.py
+++ b/Lib/test/test_struct.py
@@ -471,7 +471,7 @@ class StructTest(unittest.TestCase):
     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 @@ class StructTest(unittest.TestCase):
 
 
 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()
diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py
index 2118c62..c6730cd 100644
--- a/Lib/test/test_syntax.py
+++ b/Lib/test/test_syntax.py
@@ -552,7 +552,11 @@ class SyntaxTestCase(unittest.TestCase):
 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()
diff --git a/Lib/test/test_sys.py b/Lib/test/test_sys.py
index 6768775..04e6607 100644
--- a/Lib/test/test_sys.py
+++ b/Lib/test/test_sys.py
@@ -68,7 +68,9 @@ class SysModuleTest(unittest.TestCase):
     # 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 @@ class SysModuleTest(unittest.TestCase):
             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 @@ class SizeofTest(unittest.TestCase):
         # 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
diff --git a/Lib/test/test_tarfile.py b/Lib/test/test_tarfile.py
index bc0ae58..8e48a53 100644
--- a/Lib/test/test_tarfile.py
+++ b/Lib/test/test_tarfile.py
@@ -712,7 +712,9 @@ class WriteTest(WriteTestBase):
                 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")
diff --git a/Lib/test/test_threadsignals.py b/Lib/test/test_threadsignals.py
index e1096bd..b28705f 100644
--- a/Lib/test/test_threadsignals.py
+++ b/Lib/test/test_threadsignals.py
@@ -14,7 +14,7 @@ process_pid = os.getpid()
 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 @@ def test_main():
                           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()
diff --git a/Lib/test/test_trace.py b/Lib/test/test_trace.py
index f69af8d..df8c56f 100644
--- a/Lib/test/test_trace.py
+++ b/Lib/test/test_trace.py
@@ -401,7 +401,7 @@ class RaisingTraceFuncTestCase(unittest.TestCase):
         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
 
diff --git a/Lib/test/test_traceback.py b/Lib/test/test_traceback.py
index b29869a..61195a5 100644
--- a/Lib/test/test_traceback.py
+++ b/Lib/test/test_traceback.py
@@ -4,6 +4,7 @@ from _testcapi import traceback_print
 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():
     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 = '<unprintable %s object>' % X.__name__
diff --git a/Lib/test/test_transformer.py b/Lib/test/test_transformer.py
index 909cda5..6590937 100644
--- a/Lib/test/test_transformer.py
+++ b/Lib/test/test_transformer.py
@@ -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
 
diff --git a/Lib/test/test_types.py b/Lib/test/test_types.py
index 18ab9cc..d5d25b0 100644
--- a/Lib/test/test_types.py
+++ b/Lib/test/test_types.py
@@ -4,6 +4,7 @@ from test.test_support import run_unittest, have_unicode, run_with_locale
 import unittest
 import sys
 import locale
+import warnings
 
 class TypesTests(unittest.TestCase):
 
@@ -710,7 +711,13 @@ class TypesTests(unittest.TestCase):
             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()
diff --git a/Lib/test/test_undocumented_details.py b/Lib/test/test_undocumented_details.py
index ca66c19..f3508fc 100644
--- a/Lib/test/test_undocumented_details.py
+++ b/Lib/test/test_undocumented_details.py
@@ -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 @@ class TestImplementationComparisons(unittest.TestCase):
         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()
diff --git a/Lib/test/test_unittest.py b/Lib/test/test_unittest.py
index db51f77..9b24c8c 100644
--- a/Lib/test/test_unittest.py
+++ b/Lib/test/test_unittest.py
@@ -3056,7 +3056,7 @@ class Test_Assertions(TestCase):
         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 @@ class Test_Assertions(TestCase):
             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 @@ class TestDiscovery(TestCase):
             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:
diff --git a/Lib/test/test_univnewlines2k.py b/Lib/test/test_univnewlines2k.py
index 63c6fe8..c6d6e8b 100644
--- a/Lib/test/test_univnewlines2k.py
+++ b/Lib/test/test_univnewlines2k.py
@@ -80,7 +80,9 @@ class TestGenericUnivNewlines(unittest.TestCase):
 
     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)
diff --git a/Lib/test/test_urllib.py b/Lib/test/test_urllib.py
index c74b101..10c8d90 100644
--- a/Lib/test/test_urllib.py
+++ b/Lib/test/test_urllib.py
@@ -6,6 +6,7 @@ import unittest
 from test import test_support
 import os
 import mimetools
+import random
 import tempfile
 import StringIO
 
@@ -101,7 +102,7 @@ class ProxyTests(unittest.TestCase):
         # Records changes to env vars
         self.env = test_support.EnvironmentVarGuard()
         # Delete all proxy related env vars
-        for k, v in os.environ.iteritems():
+        for k in os.environ.keys():
             if 'proxy' in k.lower():
                 self.env.unset(k)
 
@@ -409,6 +410,13 @@ class QuotingTests(unittest.TestCase):
         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()
 
diff --git a/Lib/test/test_urllib2_localnet.py b/Lib/test/test_urllib2_localnet.py
index 1375e11..81f54ae 100644
--- a/Lib/test/test_urllib2_localnet.py
+++ b/Lib/test/test_urllib2_localnet.py
@@ -1,6 +1,5 @@
 #!/usr/bin/env python
 
-import mimetools
 import threading
 import urlparse
 import urllib2
@@ -8,6 +7,7 @@ import BaseHTTPServer
 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 @@ class DigestAuthHandler:
         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)
diff --git a/Lib/test/test_urllibnet.py b/Lib/test/test_urllibnet.py
index 7ab2aa2..9d31228 100644
--- a/Lib/test/test_urllibnet.py
+++ b/Lib/test/test_urllibnet.py
@@ -7,7 +7,7 @@ import socket
 import urllib
 import sys
 import os
-import mimetools
+mimetools = test_support.import_module("mimetools", deprecated=True)
 
 
 def _open_with_retry(func, host, *args, **kwargs):
diff --git a/Lib/test/test_userdict.py b/Lib/test/test_userdict.py
index c86a773..cf631ff 100644
--- a/Lib/test/test_userdict.py
+++ b/Lib/test/test_userdict.py
@@ -45,7 +45,9 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
         # 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 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
 
         # 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()
diff --git a/Lib/test/test_userlist.py b/Lib/test/test_userlist.py
index ed3e559..09fa188 100644
--- a/Lib/test/test_userlist.py
+++ b/Lib/test/test_userlist.py
@@ -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 @@ class UserListTest(list_tests.CommonTest):
         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()
diff --git a/Lib/test/test_userstring.py b/Lib/test/test_userstring.py
index b99581d..8ec9ca3 100755
--- a/Lib/test/test_userstring.py
+++ b/Lib/test/test_userstring.py
@@ -136,8 +136,11 @@ class MutableStringTest(UserStringTest):
 
 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__":
diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py
index 2106d8c..f3eb43b 100644
--- a/Lib/test/test_weakref.py
+++ b/Lib/test/test_weakref.py
@@ -54,10 +54,10 @@ class ReferencesTestCase(TestBase):
         # 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 @@ class ReferencesTestCase(TestBase):
         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 @@ class ReferencesTestCase(TestBase):
         ## 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 @@ class MappingTestCase(TestBase):
     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 @@ class MappingTestCase(TestBase):
                      "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 @@ class MappingTestCase(TestBase):
         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 @@ class MappingTestCase(TestBase):
         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 @@ class MappingTestCase(TestBase):
         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 @@ class MappingTestCase(TestBase):
 
     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])
diff --git a/Lib/test/test_whichdb.py b/Lib/test/test_whichdb.py
index 1ce816f..427e323 100644
--- a/Lib/test/test_whichdb.py
+++ b/Lib/test/test_whichdb.py
@@ -7,11 +7,13 @@ import os
 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 @@ for name in anydbm._names:
     # 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):
diff --git a/Lib/test/test_with.py b/Lib/test/test_with.py
index b572b91..3e33e31 100644
--- a/Lib/test/test_with.py
+++ b/Lib/test/test_with.py
@@ -520,7 +520,7 @@ class ExceptionalTestCase(unittest.TestCase, ContextmanagerAssertionMixin):
         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 @@ class ExitSwallowsExceptionTestCase(unittest.TestCase):
             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 @@ class ExitSwallowsExceptionTestCase(unittest.TestCase):
             def __exit__(self, t, v, tb): return False
         try:
             with EuropeanSwallow():
-                1/0
+                1 // 0
         except ZeroDivisionError:
             pass
         else:
diff --git a/Lib/test/test_wsgiref.py b/Lib/test/test_wsgiref.py
index a3bc99f..c31ef18 100755
--- a/Lib/test/test_wsgiref.py
+++ b/Lib/test/test_wsgiref.py
@@ -432,10 +432,10 @@ class HandlerTests(TestCase):
         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 @@ class HandlerTests(TestCase):
         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()
diff --git a/Lib/test/test_xmllib.py b/Lib/test/test_xmllib.py
index 0780bc9..68b883a 100644
--- a/Lib/test/test_xmllib.py
+++ b/Lib/test/test_xmllib.py
@@ -15,13 +15,10 @@ testdoc = """\
 
 nsdoc = "<foo xmlns='URI' attr='val'/>"
 
-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):
 
diff --git a/Lib/test/test_xpickle.py b/Lib/test/test_xpickle.py
index 3ed7ef7..f41c97a 100644
--- a/Lib/test/test_xpickle.py
+++ b/Lib/test/test_xpickle.py
@@ -25,7 +25,7 @@ from test import test_support
 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")
diff --git a/Lib/test/test_zipimport_support.py b/Lib/test/test_zipimport_support.py
index 1b64138..5bb66cb 100644
--- a/Lib/test/test_zipimport_support.py
+++ b/Lib/test/test_zipimport_support.py
@@ -168,8 +168,11 @@ class ZipSupportTests(ImportHooksBaseTestCase):
                 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("""\