diff options
author | Senthil Kumaran <orsenthil@gmail.com> | 2010-01-08 18:41:40 +0000 |
---|---|---|
committer | Senthil Kumaran <orsenthil@gmail.com> | 2010-01-08 18:41:40 +0000 |
commit | 3ddc435af6873c6304058d7bcbcb19ee4fba7781 (patch) | |
tree | c7a03cf0a8b856bae2ebebba55b09f775845c7ca | |
parent | 3194d1454cbc11ec477d83fff3fc749972107d29 (diff) | |
download | cpython-git-3ddc435af6873c6304058d7bcbcb19ee4fba7781.tar.gz |
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 bfbec91b0a..841ccad0b9 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 823559bb35..afde2e2514 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 c9aa3160a9..4fc99e049d 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 7ec4bb1e13..d17c94887f 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 fd6cafce7e..56c53dad3f 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 14303aa4ad..f6b15bf645 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 d10255de41..e484f79c2c 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 0cdc2c321d..a01dd0bd9f 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 63f7083d33..004501acb5 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 e5920329f1..f16da156db 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 a5b7cc4aaa..51db28b808 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 cb1b2f5768..a3adaf3beb 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 c531c656db..6a1f972cbf 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 8ae8f42955..b1ef626a9a 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 2a9ef5dd7c..805d7582da 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 3bede88bf9..ac89e05598 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 f20d543006..ac5b754bbe 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 f3c7c8c394..3bbc0814f5 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 4dc3104aee..c313dcf037 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 aa26bb6242..44ebe10163 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 fc61d21a22..194b4730f6 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 67d19a6120..c6a1c17636 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 fb24d4391a..b44beab134 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 fcfa616cb7..27b6c3d56c 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 28b73325d8..efc54e514a 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 24930f8a63..a345ce629c 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 c6d50a9d05..f6950a7261 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 823e9b36a3..bbe31d838d 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 85f137e45e..4e93c87f8d 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 69f31a0e54..9fef0d2232 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 418337b57a..a044faf77f 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 c455e6b710..157b9f4fe9 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 075f9dc32f..de400aa580 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 a30f42bcd6..7b63718e56 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 7d3e72d502..a91897e417 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 bf47c6fa45..bebc43ddd6 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 de8e539e44..9e3fc5e5a1 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 fb9d55b2ee..b391561546 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 ab5bac2c30..aa672abe4f 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 f144ae782e..573a512131 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 60094dceb1..ed5aa964ed 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 e377384c87..20eceedbca 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 38a8dddb6a..c6dae363cd 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 31375dc6ee..5f54b571af 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 7fd8c62a22..f3452fafae 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 f20b26ceb0..144fcf3713 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 a90dd504a3..48ffd455de 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 f5d6e686de..5e96c6ddae 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 03f1d85111..d69aecf061 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 7b8f3de8a9..bb99dab1b9 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 71d0633337..3772a58e94 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 1943518e8a..ad84589358 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 548850ad1e..01b1c36af4 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 7669182416..af89d185b0 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 3afe3a9ae1..36245b7467 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 daf7ddefd8..fd0960215c 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 b6c6a844b0..94d4dd0336 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 a219450b25..69c381e060 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 c03ca1df57..6c9fd58310 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 275885678d..70b9fd9c0c 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 b11b8c95f8..f7eb47b65a 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 df047055f2..40903dc41c 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 1f6efb503f..de8d1eae12 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 c6d3a8dcc1..103d8356f8 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 8aa224a093..20b13c1f71 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 ec818d188d..5bac62a3c0 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 649d5d23bf..ffd687580f 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 2fa36b7593..e6d2e69613 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 14d0383b03..8d8c3c357c 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 494a7c3945..ef07075bfe 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 8c2b2c6f3e..d8a0280f51 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 ed0b497a78..47dcc70029 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 cf30ff9c2d..6ff53b3be2 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 bc7465a5ba..8595368fc6 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 9c598361a6..754ceb16c8 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 ffcc98da56..3b20281a02 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 56596c8751..85d898abad 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 08de8e3ad7..6aa3d4a5e7 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 faa06c5a8d..b4f37eb2a6 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 a61fb96b79..a8e239a4eb 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 167408cd3d..f3bfd3e681 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 5aca13528a..4ba2e2a488 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 556a5764eb..76a29cde5f 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 2118c62de8..c6730cd83e 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 6768775c99..04e6607193 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 bc0ae5899d..8e48a53bb3 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 e1096bdbae..b28705f3a3 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 f69af8d40a..df8c56f758 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 b29869ac8f..61195a5d03 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 909cda5183..65909372e6 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 18ab9cc84b..d5d25b0b30 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 ca66c19f65..f3508fcfac 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 db51f77d7b..9b24c8c153 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 63c6fe8240..c6d6e8bb86 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 c74b101713..10c8d90478 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 1375e112b8..81f54aee12 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 7ab2aa2477..9d312281ae 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 c86a773135..cf631fffc6 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 ed3e559373..09fa188b19 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 b99581d6de..8ec9ca3f3e 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 2106d8cd9b..f3eb43b2e2 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 1ce816f866..427e323f49 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 b572b912d0..3e33e3156f 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 a3bc99fcf1..c31ef18991 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 0780bc95f3..68b883a0e5 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 3ed7ef7c46..f41c97adce 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 1b64138884..5bb66cb0ec 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("""\ |