Merged revisions 79165 via svnmerge from

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r79165 | florent.xicluna | 2010-03-21 03:14:24 +0200 (Sun, 21 Mar 2010) | 2 lines

  #7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper.
........

Lib/test/list_tests.py

@@ -36,7 +36,7 @@ class CommonTest(seq_tests.CommonTest):
 
         self.assertEqual(str(a0), str(l0))
         self.assertEqual(repr(a0), repr(l0))
-        self.assertEqual(`a2`, `l2`)
+        self.assertEqual(repr(a2), repr(l2))
         self.assertEqual(str(a2), "[0, 1, 2]")
         self.assertEqual(repr(a2), "[0, 1, 2]")
 
@@ -419,6 +419,11 @@ class CommonTest(seq_tests.CommonTest):
         self.assertRaises(TypeError, u.reverse, 42)
 
     def test_sort(self):
+        with test_support._check_py3k_warnings(
+                ("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])

Lib/test/mapping_tests.py

 # tests common to dict and UserDict
 import unittest
 import UserDict
+import test_support
 
 
 class BasicTestMappingProtocol(unittest.TestCase):
@@ -54,13 +55,17 @@ 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.assert_(d.has_key(k))
-            self.assert_(k in d)
+            self.assertTrue(k in d)
         for k in self.other:
-            self.failIf(d.has_key(k))
-            self.failIf(k in d)
+            self.assertTrue(k not in d)
+        #has_key
+        with test_support._check_py3k_warnings(quiet=True):
+            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)

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)
+    with test_support._check_py3k_warnings(("buffer.. not supported",
+                                             DeprecationWarning)):
+        test_support.run_unittest(TestBufferStringIO, TestBuffercStringIO)
 
 if __name__ == '__main__':
     test_main()

Lib/test/test_array.py

@@ -728,7 +728,8 @@ class BaseTest(unittest.TestCase):
 
     def test_buffer(self):
         a = array.array(self.typecode, self.example)
-        b = buffer(a)
+        with test_support._check_py3k_warnings():
+            b = buffer(a)
         self.assertEqual(b[0], a.tostring()[0])
 
     def test_weakref(self):

Lib/test/test_ast.py

@@ -272,7 +272,9 @@ class ASTHelpers_Test(unittest.TestCase):
         self.assertRaises(ValueError, ast.literal_eval, 'foo()')
 
 def test_main():
-    test_support.run_unittest(AST_Tests, ASTHelpers_Test)
+    with test_support._check_py3k_warnings(("backquote not supported",
+                                             SyntaxWarning)):
+        test_support.run_unittest(AST_Tests, ASTHelpers_Test)
 
 def main():
     if __name__ != '__main__':

Lib/test/test_augassign.py

 # Augmented assignment test.
 
-from test.test_support import run_unittest
+from test.test_support import run_unittest, _check_py3k_warnings
 import unittest
 
 
@@ -321,7 +321,8 @@ __ilshift__ called
 '''.splitlines())
 
 def test_main():
-    run_unittest(AugAssignTest)
+    with _check_py3k_warnings(("classic int division", DeprecationWarning)):
+        run_unittest(AugAssignTest)
 
 if __name__ == '__main__':
     test_main()

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.failUnless(len(repr(s)) > size)
@@ -1053,7 +1053,8 @@ class BufferTest(unittest.TestCase):
     @precisionbigmemtest(size=_1G, memuse=4)
     def test_repeat(self, size):
         try:
-            b = buffer("AAAA")*size
+            with test_support._check_py3k_warnings():
+                b = buffer("AAAA")*size
         except MemoryError:
             pass # acceptable on 32-bit
         else:

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,9 @@ class BoolTest(unittest.TestCase):
         self.assertIs(hasattr([], "wobble"), False)
 
     def test_callable(self):
-        self.assertIs(callable(len), True)
-        self.assertIs(callable(1), False)
+        with test_support._check_py3k_warnings():
+            self.assertIs(callable(len), True)
+            self.assertIs(callable(1), False)
 
     def test_isinstance(self):
         self.assertIs(isinstance(True, bool), True)
@@ -184,8 +185,11 @@ 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)
+        with test_support._check_py3k_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,9 @@ 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)
+        with test_support._check_py3k_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)

Lib/test/test_buffer.py

@@ -23,7 +23,9 @@ class BufferTests(unittest.TestCase):
 
 
 def test_main():
-    test_support.run_unittest(BufferTests)
+    with test_support._check_py3k_warnings(("buffer.. not supported",
+                                           DeprecationWarning)):
+        test_support.run_unittest(BufferTests)
 
 if __name__ == "__main__":
     test_main()

Lib/test/test_builtin.py

 # Python test set -- built-in functions
 
 import platform
-import test.test_support, unittest
-from test.test_support import fcmp, have_unicode, TESTFN, unlink, \
-    run_unittest, run_with_locale, check_warnings
+import unittest
+import warnings
+from test.test_support import (fcmp, have_unicode, TESTFN, unlink,
+                              run_unittest, _check_py3k_warnings, check_warnings)
 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")
-
+import sys, cStringIO, random, UserDict
 # count the number of test runs.
 # used to skip running test_execfile() multiple times
 # and to create unique strings to intern in test_intern()
@@ -419,7 +415,9 @@ class BuiltinTest(unittest.TestCase):
     f.write('z = z+1\n')
     f.write('z = z*2\n')
     f.close()
-    execfile(TESTFN)
+    with _check_py3k_warnings(("execfile.. not supported in 3.x",
+                              DeprecationWarning)):
+        execfile(TESTFN)
 
     def test_execfile(self):
         global numruns
@@ -1073,7 +1071,10 @@ class BuiltinTest(unittest.TestCase):
 
         # Reject floats when it would require PyLongs to represent.
         # (smaller floats still accepted, but deprecated)
-        self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
+        with check_warnings() as w:
+            warnings.simplefilter("always")
+            self.assertRaises(TypeError, range, 1e100, 1e101, 1e101)
+            self.assertEqual(w.category, DeprecationWarning)
         with check_warnings() as w:
             warnings.simplefilter("always")
             self.assertEqual(range(1.0), [0])
@@ -1119,19 +1120,20 @@ class BuiltinTest(unittest.TestCase):
 
         # Exercise various combinations of bad arguments, to check
         # refcounting logic
-        self.assertRaises(TypeError, range, 1e100)
-
-        self.assertRaises(TypeError, range, 0, 1e100)
-        self.assertRaises(TypeError, range, 1e100, 0)
-        self.assertRaises(TypeError, range, 1e100, 1e100)
-
-        self.assertRaises(TypeError, range, 0, 0, 1e100)
-        self.assertRaises(TypeError, range, 0, 1e100, 1)
-        self.assertRaises(TypeError, range, 0, 1e100, 1e100)
-        self.assertRaises(TypeError, range, 1e100, 0, 1)
-        self.assertRaises(TypeError, range, 1e100, 0, 1e100)
-        self.assertRaises(TypeError, range, 1e100, 1e100, 1)
-        self.assertRaises(TypeError, range, 1e100, 1e100, 1e100)
+        with check_warnings():
+            self.assertRaises(TypeError, range, 1e100)
+
+            self.assertRaises(TypeError, range, 0, 1e100)
+            self.assertRaises(TypeError, range, 1e100, 0)
+            self.assertRaises(TypeError, range, 1e100, 1e100)
+
+            self.assertRaises(TypeError, range, 0, 0, 1e100)
+            self.assertRaises(TypeError, range, 0, 1e100, 1)
+            self.assertRaises(TypeError, range, 0, 1e100, 1e100)
+            self.assertRaises(TypeError, range, 1e100, 0, 1)
+            self.assertRaises(TypeError, range, 1e100, 0, 1e100)
+            self.assertRaises(TypeError, range, 1e100, 1e100, 1)
+            self.assertRaises(TypeError, range, 1e100, 1e100, 1e100)
 
     def test_input_and_raw_input(self):
         self.write_testfile()

Lib/test/test_call.py

@@ -12,7 +12,8 @@ class CFunctionCalls(unittest.TestCase):
         self.assertRaises(TypeError, {}.has_key)
 
     def test_varargs1(self):
-        {}.has_key(0)
+        with test_support._check_py3k_warnings():
+            {}.has_key(0)
 
     def test_varargs2(self):
         self.assertRaises(TypeError, {}.has_key, 0, 1)
@@ -24,11 +25,13 @@ class CFunctionCalls(unittest.TestCase):
             pass
 
     def test_varargs1_ext(self):
-        {}.has_key(*(0,))
+        with test_support._check_py3k_warnings():
+            {}.has_key(*(0,))
 
     def test_varargs2_ext(self):
         try:
-            {}.has_key(*(1, 2))
+            with test_support._check_py3k_warnings():
+                {}.has_key(*(1, 2))
         except TypeError:
             pass
         else:

Lib/test/test_class.py

@@ -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,11 @@ class ClassTests(unittest.TestCase):
         hash(a.f)
 
 def test_main():
-    test_support.run_unittest(ClassTests)
+    with test_support._check_py3k_warnings(
+            (".+__(get|set|del)slice__ has been removed", DeprecationWarning),
+            ("classic int division", DeprecationWarning),
+            ("<> not supported", DeprecationWarning)):
+        test_support.run_unittest(ClassTests)
 
 if __name__=='__main__':
     test_main()

Lib/test/test_ctypes.py

 import unittest
 
-from test.test_support import run_unittest
-import ctypes.test
+from test.test_support import run_unittest, import_module, _check_py3k_warnings
+#Skip tests if _ctypes module does not exist
+import_module('_ctypes')
+
 
 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 _check_py3k_warnings(("buffer.. not supported", DeprecationWarning),
+                             ("classic (int|long) division", DeprecationWarning)):
+        import ctypes.test
+        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))
 
 if __name__ == "__main__":
     test_main()

Lib/test/test_descr.py

@@ -4433,9 +4433,14 @@ class PTypesLongInitTest(unittest.TestCase):
 
 
 def test_main():
-    # Run all local test cases, with PTypesLongInitTest first.
-    test_support.run_unittest(PTypesLongInitTest, OperatorsTest,
-                              ClassPropertiesAndMethods, DictProxyTests)
+    with test_support._check_py3k_warnings(
+            ("classic (int|long) division", DeprecationWarning),
+            ("coerce.. not supported", DeprecationWarning),
+            ("Overriding __cmp__ ", DeprecationWarning),
+            (".+__(get|set|del)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()

Lib/test/test_doctest.py

@@ -2222,7 +2222,7 @@ We don't want `-v` in sys.argv for these tests.
     >>> doctest.master = None  # Reset master.
 
 (Note: we'll be clearing doctest.master after each call to
-`doctest.testfile`, to supress warnings about multiple tests with the
+`doctest.testfile`, to suppress warnings about multiple tests with the
 same name.)
 
 Globals may be specified with the `globs` and `extraglobs` parameters:
@@ -2386,12 +2386,6 @@ bothering with the current sys.stdout encoding.
 # that these use the deprecated doctest.Tester, so should go away (or
 # be rewritten) someday.
 
-# Ignore all warnings about the use of class Tester in this module.
-# Note that the name of this module may differ depending on how it's
-# imported, so the use of __name__ is important.
-warnings.filterwarnings("ignore", "class Tester", DeprecationWarning,
-                        __name__, 0)
-
 def old_test1(): r"""
 >>> from doctest import Tester
 >>> t = Tester(globs={'x': 42}, verbose=0)
@@ -2515,9 +2509,16 @@ def old_test4(): """
 def test_main():
     # Check the doctest cases in doctest itself:
     test_support.run_doctest(doctest, verbosity=True)
-    # Check the doctest cases defined here:
+
     from test import test_doctest
-    test_support.run_doctest(test_doctest, verbosity=True)
+    with test_support._check_py3k_warnings(
+            ("backquote not supported", SyntaxWarning),
+            ("execfile.. not supported", DeprecationWarning)):
+        # Ignore all warnings about the use of class Tester in this module.
+        warnings.filterwarnings("ignore", "class Tester is deprecated",
+                                DeprecationWarning)
+        # Check the doctest cases defined here:
+        test_support.run_doctest(test_doctest, verbosity=True)
 
 import trace, sys
 def test_coverage(coverdir):

Lib/test/test_heapq.py

@@ -358,7 +358,10 @@ 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_py3k_warnings(
+                            ("comparing unequal types not supported",
+                             DeprecationWarning), quiet=True):
+                        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))

Lib/test/test_inspect.py

@@ -4,10 +4,13 @@ import unittest
 import inspect
 import datetime
 
-from test.test_support import TESTFN, run_unittest
+from test.test_support import run_unittest, _check_py3k_warnings
 
-from test import inspect_fodder as mod
-from test import inspect_fodder2 as mod2
+with _check_py3k_warnings(
+        ("tuple parameter unpacking has been removed", SyntaxWarning),
+        quiet=True):
+    from test import inspect_fodder as mod
+    from test import inspect_fodder2 as mod2
 
 # Functions tested in this suite:
 # ismodule, isclass, ismethod, isfunction, istraceback, isframe, iscode,
@@ -26,7 +29,7 @@ if modfile.endswith(('c', 'o')):
 import __builtin__
 
 try:
-    1/0
+    1 // 0
 except:
     tb = sys.exc_traceback
 
@@ -361,11 +364,14 @@ class TestClassesAndFunctions(unittest.TestCase):
         self.assertArgSpecEquals(A.m, ['self'])
 
     def test_getargspec_sublistofone(self):
-        def sublistOfOne((foo,)): return 1
-        self.assertArgSpecEquals(sublistOfOne, [['foo']])
-
-        def fakeSublistOfOne((foo)): return 1
-        self.assertArgSpecEquals(fakeSublistOfOne, ['foo'])
+        with _check_py3k_warnings(
+                ("tuple parameter unpacking has been removed", SyntaxWarning),
+                ("parenthesized argument names are invalid", SyntaxWarning)):
+            exec 'def sublistOfOne((foo,)): return 1'
+            self.assertArgSpecEquals(sublistOfOne, [['foo']])
+
+            exec 'def fakeSublistOfOne((foo)): return 1'
+            self.assertArgSpecEquals(fakeSublistOfOne, ['foo'])
 
     def test_classify_oldstyle(self):
         class A:

Lib/test/test_iter.py

 # 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_py3k_warnings
 
 # Test result of triple loop (too big to inline)
 TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2),
@@ -389,21 +390,24 @@ class TestCase(unittest.TestCase):
 
     # Test map()'s use of iterators.
     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))
 
         d = {"one": 1, "two": 2, "three": 3}
-        self.assertEqual(map(None, d), d.keys())
         self.assertEqual(map(lambda k, d=d: (k, d[k]), d), d.items())
         dkeys = d.keys()
         expected = [(i < len(d) and dkeys[i] or None,
                      i,
                      i < len(d) and dkeys[i] or None)
                     for i in range(5)]
-        self.assertEqual(map(None, d,
-                                   SequenceClass(5),
-                                   iter(d.iterkeys())),
-                         expected)
+
+        # Deprecated map(None, ...)
+        with _check_py3k_warnings():
+            self.assertEqual(map(None, SequenceClass(5)), range(5))
+            self.assertEqual(map(None, d), d.keys())
+            self.assertEqual(map(None, d,
+                                       SequenceClass(5),
+                                       iter(d.iterkeys())),
+                             expected)
 
         f = open(TESTFN, "w")
         try:
@@ -499,7 +503,11 @@ 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):
+        with _check_py3k_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)

Lib/test/test_long.py

@@ -561,11 +561,12 @@ 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))
+        with test_support._check_py3k_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
 
@@ -605,8 +606,9 @@ class LongTest(unittest.TestCase):
                 checkit(x, '*', y)
 
                 if y:
-                    expected = longx / longy
-                    got = x / y
+                    with test_support._check_py3k_warnings():
+                        expected = longx / longy
+                        got = x / y
                     checkit(x, '/', y)
 
                     expected = longx // longy

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)
+            with test_support._check_py3k_warnings(("buffer.. not supported",
+                                                     DeprecationWarning)):
+                b = buffer(s)
             new = marshal.loads(marshal.dumps(b))
             self.assertEqual(s, new)
             marshal.dump(b, file(test_support.TESTFN, "wb"))

Lib/test/test_multiprocessing.py

@@ -1934,7 +1934,9 @@ def test_main(run=None):
 
     loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase
     suite = unittest.TestSuite(loadTestsFromTestCase(tc) for tc in testcases)
-    run(suite)
+    with test_support._check_py3k_warnings(
+            (".+__(get|set)slice__ has been removed", DeprecationWarning)):
+        run(suite)
 
     ThreadsMixin.pool.terminate()
     ProcessesMixin.pool.terminate()

Lib/test/test_operator.py

@@ -192,7 +192,9 @@ class OperatorTestCase(unittest.TestCase):
         class C:
             pass
         def check(self, o, v):
-            self.assert_(operator.isCallable(o) == callable(o) == v)
+            with test_support._check_py3k_warnings():
+                self.assertEqual(operator.isCallable(o), v)
+                self.assertEqual(callable(o), v)
         check(self, 4, 0)
         check(self, operator.isCallable, 1)
         check(self, C, 1)
@@ -302,12 +304,13 @@ class OperatorTestCase(unittest.TestCase):
         self.assertRaises(ValueError, operator.rshift, 2, -1)
 
     def test_contains(self):
-        self.failUnlessRaises(TypeError, operator.contains)
-        self.failUnlessRaises(TypeError, operator.contains, None, None)
-        self.failUnless(operator.contains(range(4), 2))
-        self.failIf(operator.contains(range(4), 5))
-        self.failUnless(operator.sequenceIncludes(range(4), 2))
-        self.failIf(operator.sequenceIncludes(range(4), 5))
+        self.assertRaises(TypeError, operator.contains)
+        self.assertRaises(TypeError, operator.contains, None, None)
+        self.assertTrue(operator.contains(range(4), 2))
+        self.assertFalse(operator.contains(range(4), 5))
+        with test_support._check_py3k_warnings():
+            self.assertTrue(operator.sequenceIncludes(range(4), 2))
+            self.assertFalse(operator.sequenceIncludes(range(4), 5))
 
     def test_setitem(self):
         a = range(3)

Lib/test/test_peepholer.py

@@ -207,17 +207,20 @@ def test_main(verbose=None):
     import sys
     from test import test_support
     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 test_support._check_py3k_warnings(
+            ("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)

Lib/test/test_richcmp.py

@@ -330,7 +330,12 @@ 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 test_support._check_py3k_warnings(("dict inequality comparisons "
+                                             "not supported in 3.x",
+                                             DeprecationWarning)):
+        test_support.run_unittest(DictTest)
+
 
 if __name__ == "__main__":
     test_main()

Lib/test/test_set.py

@@ -1348,6 +1348,10 @@ class TestOnlySetsOperator(TestOnlySetsInBinaryOps):
         self.other = operator.add
         self.otherIsIterable = False
 
+    def test_ge_gt_le_lt(self):
+        with test_support._check_py3k_warnings():
+            super(TestOnlySetsOperator, self).test_ge_gt_le_lt()
+
 #------------------------------------------------------------------------------
 
 class TestOnlySetsTuple(TestOnlySetsInBinaryOps):

Lib/test/test_sets.py

 #!/usr/bin/env python
 
-import warnings
-warnings.filterwarnings("ignore", "the sets module is deprecated",
-                        DeprecationWarning, "test\.test_sets")
-
 import unittest, operator, copy, pickle, random
-from sets import Set, ImmutableSet
 from test import test_support
 
+test_support.import_module("sets", deprecated=True)
+from sets import Set, ImmutableSet
+
 empty_set = Set()
 
 #==============================================================================
@@ -638,6 +636,10 @@ class TestOnlySetsOperator(TestOnlySetsInBinaryOps):
         self.other = operator.add
         self.otherIsIterable = False
 
+    def test_ge_gt_le_lt(self):
+        with test_support._check_py3k_warnings():
+            super(TestOnlySetsOperator, self).test_ge_gt_le_lt()
+
 #------------------------------------------------------------------------------
 
 class TestOnlySetsTuple(TestOnlySetsInBinaryOps):
@@ -679,11 +681,12 @@ 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()
+        self.assertEqual(len(dup), len(self.set))
+        dup_list = sorted(dup)
+        set_list = sorted(self.set)
         self.assertEqual(len(dup_list), len(set_list))
-        for i in range(len(dup_list)):
-            self.failUnless(dup_list[i] is set_list[i])
+        for i, el in enumerate(dup_list):
+            self.assertTrue(el is set_list[i])
 
     def test_deep_copy(self):
         dup = copy.deepcopy(self.set)
@@ -694,6 +697,7 @@ class TestCopying(unittest.TestCase):
         for i in range(len(dup_list)):
             self.assertEqual(dup_list[i], set_list[i])
 
+
 #------------------------------------------------------------------------------
 
 class TestCopyingEmpty(TestCopying):
@@ -712,6 +716,10 @@ class TestCopyingTriple(TestCopying):
     def setUp(self):
         self.set = Set(["zero", 0, None])
 
+    def test_copy(self):
+        with test_support._check_py3k_warnings():
+            super(TestCopyingTriple, self).test_copy()
+
 #------------------------------------------------------------------------------
 
 class TestCopyingTuple(TestCopying):

Lib/test/test_slice.py

@@ -115,7 +115,8 @@ class SliceTest(unittest.TestCase):
                 tmp.append((i, j, k))
 
         x = X()
-        x[1:2] = 42
+        with test_support._check_py3k_warnings():
+            x[1:2] = 42
         self.assertEquals(tmp, [(1, 2, 42)])
 
     def test_pickle(self):

Lib/test/test_socket.py

@@ -123,8 +123,9 @@ class ThreadableTest:
         self.server_ready.wait()
         self.client_ready.set()
         self.clientSetUp()
-        if not callable(test_func):
-            raise TypeError, "test_func must be a callable function"
+        with test_support._check_py3k_warnings():
+            if not callable(test_func):
+                raise TypeError("test_func must be a callable function.")
         try:
             test_func()
         except Exception, strerror:
@@ -132,7 +133,7 @@ class ThreadableTest:
         self.clientTearDown()
 
     def clientSetUp(self):
-        raise NotImplementedError, "clientSetUp must be implemented."
+        raise NotImplementedError("clientSetUp must be implemented.")
 
     def clientTearDown(self):
         self.done.set()
@@ -282,8 +283,8 @@ class GeneralModuleTests(unittest.TestCase):
                 orig = sys.getrefcount(__name__)
                 socket.getnameinfo(__name__,0)
             except TypeError:
-                if sys.getrefcount(__name__) <> orig:
-                    self.fail("socket.getnameinfo loses a reference")
+                self.assertEqual(sys.getrefcount(__name__), orig,
+                                 "socket.getnameinfo loses a reference")
 
     def testInterpreterCrash(self):
         # Making sure getnameinfo doesn't crash the interpreter
@@ -1198,7 +1199,8 @@ class BufferIOTest(SocketConnectedTest):
         self.assertEqual(msg, MSG)
 
     def _testRecvInto(self):
-        buf = buffer(MSG)
+        with test_support._check_py3k_warnings():
+            buf = buffer(MSG)
         self.serv_conn.send(buf)
 
     def testRecvFromInto(self):
@@ -1209,7 +1211,8 @@ class BufferIOTest(SocketConnectedTest):
         self.assertEqual(msg, MSG)
 
     def _testRecvFromInto(self):
-        buf = buffer(MSG)
+        with test_support._check_py3k_warnings():
+            buf = buffer(MSG)
         self.serv_conn.send(buf)
 
 

Lib/test/test_sort.py

@@ -185,7 +185,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 +207,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 +274,19 @@ 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 test_support._check_py3k_warnings(
+            ("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)

Lib/test/test_ssl.py

@@ -975,7 +975,8 @@ 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)
+                with test_support._check_py3k_warnings():
+                    f = urllib.urlopen(url)
                 dlen = f.info().getheader("content-length")
                 if dlen and (int(dlen) > 0):
                     d2 = f.read(int(dlen))

Lib/test/test_syntax.py

@@ -506,7 +506,9 @@ 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 test_support._check_py3k_warnings(("backquote not supported",
+                                             SyntaxWarning)):
+        test_support.run_doctest(test_syntax, verbosity=True)
 
 if __name__ == "__main__":
     test_main()

Lib/test/test_types.py

 # Python test set -- part 6, built-in types
 
-from test.test_support import run_unittest, have_unicode, run_with_locale
+from test.test_support import run_unittest, have_unicode, run_with_locale, \
+                              _check_py3k_warnings
 import unittest
 import sys
 import locale
@@ -639,7 +640,10 @@ class TypesTests(unittest.TestCase):
 
 
 def test_main():
-    run_unittest(TypesTests)
+    with _check_py3k_warnings(
+            ("buffer.. not supported", DeprecationWarning),
+            ("classic long division", DeprecationWarning)):
+        run_unittest(TypesTests)
 
 if __name__ == '__main__':
     test_main()

Lib/test/test_undocumented_details.py

-from test.test_support import run_unittest, have_unicode
+from test.test_support import run_unittest, _check_py3k_warnings
 import unittest
 import sys
 
@@ -33,7 +33,8 @@ class TestImplementationComparisons(unittest.TestCase):
         self.assertTrue(g_cell != h_cell)
 
 def test_main():
-    run_unittest(TestImplementationComparisons)
+    with _check_py3k_warnings():
+        run_unittest(TestImplementationComparisons)
 
 if __name__ == '__main__':
     test_main()

Lib/test/test_userdict.py

@@ -45,7 +45,7 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
         # Test __repr__
         self.assertEqual(str(u0), str(d0))
         self.assertEqual(repr(u1), repr(d1))
-        self.assertEqual(`u2`, `d2`)
+        self.assertEqual(repr(u2), repr(d2))
 
         # Test __cmp__ and __len__
         all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
@@ -95,12 +95,13 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
 
         # Test has_key and "in".
         for i in u2.keys():
-            self.assert_(u2.has_key(i))
-            self.assert_(i in u2)
-            self.assertEqual(u1.has_key(i), d1.has_key(i))
+            self.assertTrue(i in u2)
             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)
+            with test_support._check_py3k_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()

Lib/test/test_userlist.py

@@ -53,7 +53,9 @@ class UserListTest(list_tests.CommonTest):
         self.assertEqual(iter(T((1,2))).next(), "0!!!")
 
 def test_main():
-    test_support.run_unittest(UserListTest)
+    with test_support._check_py3k_warnings(
+            (".+__(get|set|del)slice__ has been removed", DeprecationWarning)):
+        test_support.run_unittest(UserListTest)
 
 if __name__ == "__main__":
     test_main()

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,8 @@ class ReferencesTestCase(TestBase):
         p.append(12)
         self.assertEqual(len(L), 1)
         self.failUnless(p, "proxy for non-empty UserList should be true")
-        p[:] = [2, 3]
+        with test_support._check_py3k_warnings():
+            p[:] = [2, 3]
         self.assertEqual(len(L), 2)
         self.assertEqual(len(p), 2)
         self.failUnless(3 in p,
@@ -183,10 +184,11 @@ 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])
+        with test_support._check_py3k_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 +834,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 +856,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.assert_(dict.has_key(o))
-        self.assert_(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,8 +869,7 @@ class MappingTestCase(TestBase):
         objects2 = list(objects)
         for wr in refs:
             ob = wr()
-            self.assert_(dict.has_key(ob))
-            self.assert_(ob in dict)
+            self.assertTrue(ob in dict)
             self.assertEqual(ob.arg, dict[ob])
             objects2.remove(ob)
         self.assertEqual(len(objects2), 0)
@@ -878,8 +879,7 @@ class MappingTestCase(TestBase):
         self.assertEqual(len(list(dict.iterkeyrefs())), len(objects))
         for wr in dict.iterkeyrefs():
             ob = wr()
-            self.assert_(dict.has_key(ob))
-            self.assert_(ob in dict)
+            self.assertTrue(ob in dict)
             self.assertEqual(ob.arg, dict[ob])
             objects2.remove(ob)
         self.assertEqual(len(objects2), 0)
@@ -992,16 +992,16 @@ class MappingTestCase(TestBase):
                      " -- value parameters must be distinct objects")
         weakdict = klass()
         o = weakdict.setdefault(key, value1)
-        self.assert_(o is value1)
-        self.assert_(weakdict.has_key(key))
-        self.assert_(weakdict.get(key) is value1)
-        self.assert_(weakdict[key] is value1)
+        self.assertTrue(o is value1)
+        self.assertTrue(key in weakdict)
+        self.assertTrue(weakdict.get(key) is value1)
+        self.assertTrue(weakdict[key] is value1)
 
         o = weakdict.setdefault(key, value2)
-        self.assert_(o is value1)
-        self.assert_(weakdict.has_key(key))
-        self.assert_(weakdict.get(key) is value1)
-        self.assert_(weakdict[key] is value1)
+        self.assertTrue(o is value1)
+        self.assertTrue(key in weakdict)
+        self.assertTrue(weakdict.get(key) is value1)
+        self.assertTrue(weakdict[key] is value1)
 
     def test_weak_valued_dict_setdefault(self):
         self.check_setdefault(weakref.WeakValueDictionary,
@@ -1013,24 +1013,24 @@ 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.assert_(len(weakdict) == len(dict))
+        self.assertEqual(len(weakdict), len(dict))
         for k in weakdict.keys():
-            self.assert_(dict.has_key(k),
+            self.assertTrue(k in dict,
                          "mysterious new key appeared in weak dict")
             v = dict.get(k)
-            self.assert_(v is weakdict[k])
-            self.assert_(v is weakdict.get(k))
+            self.assertTrue(v is weakdict[k])
+            self.assertTrue(v is weakdict.get(k))
         for k in dict.keys():
-            self.assert_(weakdict.has_key(k),
+            self.assertTrue(k in weakdict,
                          "original key disappeared in weak dict")
             v = dict[k]
-            self.assert_(v is weakdict[k])
-            self.assert_(v is weakdict.get(k))
+            self.assertTrue(v is weakdict[k])
+            self.assertTrue(v is weakdict.get(k))
 
     def test_weak_valued_dict_update(self):
         self.check_update(weakref.WeakValueDictionary,

Lib/test/test_zipimport_support.py

@@ -14,6 +14,7 @@ import doctest
 import inspect
 import linecache
 import pdb
+import warnings
 
 verbose = test.test_support.verbose
 
@@ -170,8 +171,15 @@ 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)
+            # Needed for test_DocTestParser and test_debug
+            with test.test_support._check_py3k_warnings(
+                    ("backquote not supported", SyntaxWarning),
+                    ("execfile.. not supported", DeprecationWarning)):
+                # Ignore all warnings about the use of class Tester in this module.
+                warnings.filterwarnings("ignore", "class Tester is deprecated",
+                                        DeprecationWarning)
+                for obj in known_good_tests:
+                    _run_object_doctest(obj, test_zipped_doctest)
 
     def test_doctest_main_issue4197(self):
         test_src = textwrap.dedent("""\