#7092 - Silence more py3k deprecation warnings, using test_support.check_py3k_warnings() helper.
This commit is contained in:
parent
8cb253f8d6
commit
0762788081
|
@ -36,7 +36,7 @@ class CommonTest(seq_tests.CommonTest):
|
|||
|
||||
self.assertEqual(str(a0), str(l0))
|
||||
self.assertEqual(repr(a0), repr(l0))
|
||||
self.assertEqual(`a2`, `l2`)
|
||||
self.assertEqual(repr(a2), repr(l2))
|
||||
self.assertEqual(str(a2), "[0, 1, 2]")
|
||||
self.assertEqual(repr(a2), "[0, 1, 2]")
|
||||
|
||||
|
@ -421,6 +421,11 @@ class CommonTest(seq_tests.CommonTest):
|
|||
self.assertRaises(TypeError, u.reverse, 42)
|
||||
|
||||
def test_sort(self):
|
||||
with test_support.check_py3k_warnings(
|
||||
("the cmp argument is not supported", DeprecationWarning)):
|
||||
self._test_sort()
|
||||
|
||||
def _test_sort(self):
|
||||
u = self.type2test([1, 0])
|
||||
u.sort()
|
||||
self.assertEqual(u, [0, 1])
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
# tests common to dict and UserDict
|
||||
import unittest
|
||||
import UserDict
|
||||
import test_support
|
||||
|
||||
|
||||
class BasicTestMappingProtocol(unittest.TestCase):
|
||||
|
@ -54,13 +55,17 @@ class BasicTestMappingProtocol(unittest.TestCase):
|
|||
#len
|
||||
self.assertEqual(len(p), 0)
|
||||
self.assertEqual(len(d), len(self.reference))
|
||||
#has_key
|
||||
#in
|
||||
for k in self.reference:
|
||||
self.assertTrue(d.has_key(k))
|
||||
self.assertIn(k, d)
|
||||
for k in self.other:
|
||||
self.assertFalse(d.has_key(k))
|
||||
self.assertNotIn(k, d)
|
||||
#has_key
|
||||
with test_support.check_py3k_warnings(quiet=True):
|
||||
for k in self.reference:
|
||||
self.assertTrue(d.has_key(k))
|
||||
for k in self.other:
|
||||
self.assertFalse(d.has_key(k))
|
||||
#cmp
|
||||
self.assertEqual(cmp(p,p), 0)
|
||||
self.assertEqual(cmp(d,d), 0)
|
||||
|
|
|
@ -137,12 +137,10 @@ class TestBuffercStringIO(TestcStringIO):
|
|||
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(
|
||||
TestStringIO,
|
||||
TestcStringIO,
|
||||
TestBufferStringIO,
|
||||
TestBuffercStringIO
|
||||
)
|
||||
test_support.run_unittest(TestStringIO, TestcStringIO)
|
||||
with test_support.check_py3k_warnings(("buffer.. not supported",
|
||||
DeprecationWarning)):
|
||||
test_support.run_unittest(TestBufferStringIO, TestBuffercStringIO)
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_main()
|
||||
|
|
|
@ -749,7 +749,8 @@ class BaseTest(unittest.TestCase):
|
|||
|
||||
def test_buffer(self):
|
||||
a = array.array(self.typecode, self.example)
|
||||
b = buffer(a)
|
||||
with test_support.check_py3k_warnings():
|
||||
b = buffer(a)
|
||||
self.assertEqual(b[0], a.tostring()[0])
|
||||
|
||||
def test_weakref(self):
|
||||
|
|
|
@ -302,7 +302,9 @@ class ASTHelpers_Test(unittest.TestCase):
|
|||
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(AST_Tests, ASTHelpers_Test)
|
||||
with test_support.check_py3k_warnings(("backquote not supported",
|
||||
SyntaxWarning)):
|
||||
test_support.run_unittest(AST_Tests, ASTHelpers_Test)
|
||||
|
||||
def main():
|
||||
if __name__ != '__main__':
|
||||
|
|
|
@ -1,6 +1,6 @@
|
|||
# Augmented assignment test.
|
||||
|
||||
from test.test_support import run_unittest
|
||||
from test.test_support import run_unittest, check_py3k_warnings
|
||||
import unittest
|
||||
|
||||
|
||||
|
@ -324,7 +324,8 @@ __ilshift__ called
|
|||
'''.splitlines())
|
||||
|
||||
def test_main():
|
||||
run_unittest(AugAssignTest)
|
||||
with check_py3k_warnings(("classic int division", DeprecationWarning)):
|
||||
run_unittest(AugAssignTest)
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_main()
|
||||
|
|
|
@ -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,8 @@ class BufferTest(unittest.TestCase):
|
|||
@precisionbigmemtest(size=_1G, memuse=4)
|
||||
def test_repeat(self, size):
|
||||
try:
|
||||
b = buffer("AAAA")*size
|
||||
with test_support.check_py3k_warnings():
|
||||
b = buffer("AAAA")*size
|
||||
except MemoryError:
|
||||
pass # acceptable on 32-bit
|
||||
else:
|
||||
|
|
|
@ -85,10 +85,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:
|
||||
|
@ -162,8 +162,9 @@ class BoolTest(unittest.TestCase):
|
|||
self.assertIs(hasattr([], "wobble"), False)
|
||||
|
||||
def test_callable(self):
|
||||
self.assertIs(callable(len), True)
|
||||
self.assertIs(callable(1), False)
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertIs(callable(len), True)
|
||||
self.assertIs(callable(1), False)
|
||||
|
||||
def test_isinstance(self):
|
||||
self.assertIs(isinstance(True, bool), True)
|
||||
|
@ -178,8 +179,11 @@ class BoolTest(unittest.TestCase):
|
|||
self.assertIs(issubclass(int, bool), False)
|
||||
|
||||
def test_haskey(self):
|
||||
self.assertIs({}.has_key(1), False)
|
||||
self.assertIs({1:1}.has_key(1), True)
|
||||
self.assertIs(1 in {}, False)
|
||||
self.assertIs(1 in {1:1}, True)
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertIs({}.has_key(1), False)
|
||||
self.assertIs({1:1}.has_key(1), True)
|
||||
|
||||
def test_string(self):
|
||||
self.assertIs("xyz".endswith("z"), True)
|
||||
|
@ -251,8 +255,9 @@ class BoolTest(unittest.TestCase):
|
|||
import operator
|
||||
self.assertIs(operator.truth(0), False)
|
||||
self.assertIs(operator.truth(1), True)
|
||||
self.assertIs(operator.isCallable(0), False)
|
||||
self.assertIs(operator.isCallable(len), True)
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertIs(operator.isCallable(0), False)
|
||||
self.assertIs(operator.isCallable(len), True)
|
||||
self.assertIs(operator.isNumberType(None), False)
|
||||
self.assertIs(operator.isNumberType(0), True)
|
||||
self.assertIs(operator.not_(1), False)
|
||||
|
|
|
@ -23,7 +23,9 @@ class BufferTests(unittest.TestCase):
|
|||
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(BufferTests)
|
||||
with test_support.check_py3k_warnings(("buffer.. not supported",
|
||||
DeprecationWarning)):
|
||||
test_support.run_unittest(BufferTests)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
@ -3,14 +3,10 @@
|
|||
import platform
|
||||
import unittest
|
||||
from test.test_support import fcmp, have_unicode, TESTFN, unlink, \
|
||||
run_unittest
|
||||
run_unittest, check_py3k_warnings
|
||||
from operator import neg
|
||||
|
||||
import sys, warnings, cStringIO, random, UserDict
|
||||
warnings.filterwarnings("ignore", "hex../oct.. of negative int",
|
||||
FutureWarning, __name__)
|
||||
warnings.filterwarnings("ignore", "integer argument expected",
|
||||
DeprecationWarning, "unittest")
|
||||
import sys, cStringIO, random, UserDict
|
||||
|
||||
# count the number of test runs.
|
||||
# used to skip running test_execfile() multiple times
|
||||
|
@ -419,7 +415,9 @@ class BuiltinTest(unittest.TestCase):
|
|||
f.write('z = z+1\n')
|
||||
f.write('z = z*2\n')
|
||||
f.close()
|
||||
execfile(TESTFN)
|
||||
with check_py3k_warnings(("execfile.. not supported in 3.x",
|
||||
DeprecationWarning)):
|
||||
execfile(TESTFN)
|
||||
|
||||
def test_execfile(self):
|
||||
global numruns
|
||||
|
@ -1542,17 +1540,24 @@ 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 check_py3k_warnings(
|
||||
(".+ not supported in 3.x", DeprecationWarning),
|
||||
(".+ is renamed to imp.reload", DeprecationWarning),
|
||||
("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
|
||||
|
|
|
@ -12,7 +12,8 @@ class CFunctionCalls(unittest.TestCase):
|
|||
self.assertRaises(TypeError, {}.has_key)
|
||||
|
||||
def test_varargs1(self):
|
||||
{}.has_key(0)
|
||||
with test_support.check_py3k_warnings():
|
||||
{}.has_key(0)
|
||||
|
||||
def test_varargs2(self):
|
||||
self.assertRaises(TypeError, {}.has_key, 0, 1)
|
||||
|
@ -24,11 +25,13 @@ class CFunctionCalls(unittest.TestCase):
|
|||
pass
|
||||
|
||||
def test_varargs1_ext(self):
|
||||
{}.has_key(*(0,))
|
||||
with test_support.check_py3k_warnings():
|
||||
{}.has_key(*(0,))
|
||||
|
||||
def test_varargs2_ext(self):
|
||||
try:
|
||||
{}.has_key(*(1, 2))
|
||||
with test_support.check_py3k_warnings():
|
||||
{}.has_key(*(1, 2))
|
||||
except TypeError:
|
||||
pass
|
||||
else:
|
||||
|
|
|
@ -407,7 +407,7 @@ class ClassTests(unittest.TestCase):
|
|||
self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
|
||||
|
||||
callLst[:] = []
|
||||
testme <> 1 # XXX kill this in py3k
|
||||
eval('testme <> 1') # XXX kill this in py3k
|
||||
self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (testme, 1))])
|
||||
|
||||
callLst[:] = []
|
||||
|
@ -427,7 +427,7 @@ class ClassTests(unittest.TestCase):
|
|||
self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
|
||||
|
||||
callLst[:] = []
|
||||
1 <> testme
|
||||
eval('1 <> testme')
|
||||
self.assertCallStack([("__coerce__", (testme, 1)), ('__cmp__', (1, testme))])
|
||||
|
||||
callLst[:] = []
|
||||
|
@ -616,7 +616,11 @@ class ClassTests(unittest.TestCase):
|
|||
hash(a.f)
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(ClassTests)
|
||||
with test_support.check_py3k_warnings(
|
||||
(".+__(get|set|del)slice__ has been removed", DeprecationWarning),
|
||||
("classic int division", DeprecationWarning),
|
||||
("<> not supported", DeprecationWarning)):
|
||||
test_support.run_unittest(ClassTests)
|
||||
|
||||
if __name__=='__main__':
|
||||
test_main()
|
||||
|
|
|
@ -1,15 +1,17 @@
|
|||
import unittest
|
||||
|
||||
from test.test_support import run_unittest, import_module
|
||||
from test.test_support import run_unittest, import_module, check_py3k_warnings
|
||||
#Skip tests if _ctypes module does not exist
|
||||
import_module('_ctypes')
|
||||
|
||||
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 check_py3k_warnings(("buffer.. not supported", DeprecationWarning),
|
||||
("classic (int|long) division", DeprecationWarning)):
|
||||
import ctypes.test
|
||||
skipped, testcases = ctypes.test.get_tests(ctypes.test, "test_*.py", verbosity=0)
|
||||
suites = [unittest.makeSuite(t) for t in testcases]
|
||||
run_unittest(unittest.TestSuite(suites))
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
@ -4622,9 +4622,14 @@ class PTypesLongInitTest(unittest.TestCase):
|
|||
|
||||
|
||||
def test_main():
|
||||
# Run all local test cases, with PTypesLongInitTest first.
|
||||
test_support.run_unittest(PTypesLongInitTest, OperatorsTest,
|
||||
ClassPropertiesAndMethods, DictProxyTests)
|
||||
with test_support.check_py3k_warnings(
|
||||
("classic (int|long) division", DeprecationWarning),
|
||||
("coerce.. not supported", DeprecationWarning),
|
||||
("Overriding __cmp__ ", DeprecationWarning),
|
||||
(".+__(get|set|del)slice__ has been removed", DeprecationWarning)):
|
||||
# Run all local test cases, with PTypesLongInitTest first.
|
||||
test_support.run_unittest(PTypesLongInitTest, OperatorsTest,
|
||||
ClassPropertiesAndMethods, DictProxyTests)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
@ -2169,7 +2169,7 @@ We don't want `-v` in sys.argv for these tests.
|
|||
>>> doctest.master = None # Reset master.
|
||||
|
||||
(Note: we'll be clearing doctest.master after each call to
|
||||
`doctest.testfile`, to supress warnings about multiple tests with the
|
||||
`doctest.testfile`, to suppress warnings about multiple tests with the
|
||||
same name.)
|
||||
|
||||
Globals may be specified with the `globs` and `extraglobs` parameters:
|
||||
|
@ -2333,12 +2333,6 @@ bothering with the current sys.stdout encoding.
|
|||
# that these use the deprecated doctest.Tester, so should go away (or
|
||||
# be rewritten) someday.
|
||||
|
||||
# Ignore all warnings about the use of class Tester in this module.
|
||||
# Note that the name of this module may differ depending on how it's
|
||||
# imported, so the use of __name__ is important.
|
||||
warnings.filterwarnings("ignore", "class Tester", DeprecationWarning,
|
||||
__name__, 0)
|
||||
|
||||
def old_test1(): r"""
|
||||
>>> from doctest import Tester
|
||||
>>> t = Tester(globs={'x': 42}, verbose=0)
|
||||
|
@ -2462,9 +2456,16 @@ def old_test4(): """
|
|||
def test_main():
|
||||
# Check the doctest cases in doctest itself:
|
||||
test_support.run_doctest(doctest, verbosity=True)
|
||||
# Check the doctest cases defined here:
|
||||
|
||||
from test import test_doctest
|
||||
test_support.run_doctest(test_doctest, verbosity=True)
|
||||
with test_support.check_py3k_warnings(
|
||||
("backquote not supported", SyntaxWarning),
|
||||
("execfile.. not supported", DeprecationWarning)):
|
||||
# Ignore all warnings about the use of class Tester in this module.
|
||||
warnings.filterwarnings("ignore", "class Tester is deprecated",
|
||||
DeprecationWarning)
|
||||
# Check the doctest cases defined here:
|
||||
test_support.run_doctest(test_doctest, verbosity=True)
|
||||
|
||||
import trace, sys
|
||||
def test_coverage(coverdir):
|
||||
|
|
|
@ -356,7 +356,10 @@ class TestErrorHandling(unittest.TestCase):
|
|||
for f in (self.module.nlargest, self.module.nsmallest):
|
||||
for s in ("123", "", range(1000), ('do', 1.2), xrange(2000,2200,5)):
|
||||
for g in (G, I, Ig, L, R):
|
||||
self.assertEqual(f(2, g(s)), f(2,s))
|
||||
with test_support.check_py3k_warnings(
|
||||
("comparing unequal types not supported",
|
||||
DeprecationWarning), quiet=True):
|
||||
self.assertEqual(f(2, g(s)), f(2,s))
|
||||
self.assertEqual(f(2, S(s)), [])
|
||||
self.assertRaises(TypeError, f, 2, X(s))
|
||||
self.assertRaises(TypeError, f, 2, N(s))
|
||||
|
|
|
@ -4,10 +4,13 @@ import unittest
|
|||
import inspect
|
||||
import datetime
|
||||
|
||||
from test.test_support import run_unittest
|
||||
from test.test_support import run_unittest, check_py3k_warnings
|
||||
|
||||
from test import inspect_fodder as mod
|
||||
from test import inspect_fodder2 as mod2
|
||||
with check_py3k_warnings(
|
||||
("tuple parameter unpacking has been removed", SyntaxWarning),
|
||||
quiet=True):
|
||||
from test import inspect_fodder as mod
|
||||
from test import inspect_fodder2 as mod2
|
||||
|
||||
# C module for test_findsource_binary
|
||||
import unicodedata
|
||||
|
@ -29,7 +32,7 @@ if modfile.endswith(('c', 'o')):
|
|||
import __builtin__
|
||||
|
||||
try:
|
||||
1/0
|
||||
1 // 0
|
||||
except:
|
||||
tb = sys.exc_traceback
|
||||
|
||||
|
@ -420,11 +423,14 @@ class TestClassesAndFunctions(unittest.TestCase):
|
|||
self.assertArgSpecEquals(A.m, ['self'])
|
||||
|
||||
def test_getargspec_sublistofone(self):
|
||||
def sublistOfOne((foo,)): return 1
|
||||
self.assertArgSpecEquals(sublistOfOne, [['foo']])
|
||||
with check_py3k_warnings(
|
||||
("tuple parameter unpacking has been removed", SyntaxWarning),
|
||||
("parenthesized argument names are invalid", SyntaxWarning)):
|
||||
exec 'def sublistOfOne((foo,)): return 1'
|
||||
self.assertArgSpecEquals(sublistOfOne, [['foo']])
|
||||
|
||||
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:
|
||||
|
|
|
@ -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_py3k_warnings
|
||||
|
||||
# Test result of triple loop (too big to inline)
|
||||
TRIPLETS = [(0, 0, 0), (0, 0, 1), (0, 0, 2),
|
||||
|
@ -396,21 +397,24 @@ class TestCase(unittest.TestCase):
|
|||
|
||||
# Test map()'s use of iterators.
|
||||
def test_builtin_map(self):
|
||||
self.assertEqual(map(None, SequenceClass(5)), range(5))
|
||||
self.assertEqual(map(lambda x: x+1, SequenceClass(5)), range(1, 6))
|
||||
|
||||
d = {"one": 1, "two": 2, "three": 3}
|
||||
self.assertEqual(map(None, d), d.keys())
|
||||
self.assertEqual(map(lambda k, d=d: (k, d[k]), d), d.items())
|
||||
dkeys = d.keys()
|
||||
expected = [(i < len(d) and dkeys[i] or None,
|
||||
i,
|
||||
i < len(d) and dkeys[i] or None)
|
||||
for i in range(5)]
|
||||
self.assertEqual(map(None, d,
|
||||
SequenceClass(5),
|
||||
iter(d.iterkeys())),
|
||||
expected)
|
||||
|
||||
# Deprecated map(None, ...)
|
||||
with check_py3k_warnings():
|
||||
self.assertEqual(map(None, SequenceClass(5)), range(5))
|
||||
self.assertEqual(map(None, d), d.keys())
|
||||
self.assertEqual(map(None, d,
|
||||
SequenceClass(5),
|
||||
iter(d.iterkeys())),
|
||||
expected)
|
||||
|
||||
f = open(TESTFN, "w")
|
||||
try:
|
||||
|
@ -506,7 +510,11 @@ class TestCase(unittest.TestCase):
|
|||
self.assertEqual(zip(x, y), expected)
|
||||
|
||||
# Test reduces()'s use of iterators.
|
||||
def test_builtin_reduce(self):
|
||||
def test_deprecated_builtin_reduce(self):
|
||||
with check_py3k_warnings():
|
||||
self._test_builtin_reduce()
|
||||
|
||||
def _test_builtin_reduce(self):
|
||||
from operator import add
|
||||
self.assertEqual(reduce(add, SequenceClass(5)), 10)
|
||||
self.assertEqual(reduce(add, SequenceClass(5), 42), 52)
|
||||
|
|
|
@ -574,11 +574,12 @@ class LongTest(unittest.TestCase):
|
|||
def __getslice__(self, i, j):
|
||||
return i, j
|
||||
|
||||
self.assertEqual(X()[-5L:7L], (-5, 7))
|
||||
# use the clamping effect to test the smallest and largest longs
|
||||
# that fit a Py_ssize_t
|
||||
slicemin, slicemax = X()[-2L**100:2L**100]
|
||||
self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax))
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertEqual(X()[-5L:7L], (-5, 7))
|
||||
# use the clamping effect to test the smallest and largest longs
|
||||
# that fit a Py_ssize_t
|
||||
slicemin, slicemax = X()[-2L**100:2L**100]
|
||||
self.assertEqual(X()[slicemin:slicemax], (slicemin, slicemax))
|
||||
|
||||
# ----------------------------------- tests of auto int->long conversion
|
||||
|
||||
|
@ -616,8 +617,9 @@ class LongTest(unittest.TestCase):
|
|||
checkit(x, '*', y)
|
||||
|
||||
if y:
|
||||
expected = longx / longy
|
||||
got = x / y
|
||||
with test_support.check_py3k_warnings():
|
||||
expected = longx / longy
|
||||
got = x / y
|
||||
checkit(x, '/', y)
|
||||
|
||||
expected = longx // longy
|
||||
|
|
|
@ -129,7 +129,9 @@ class StringTestCase(unittest.TestCase):
|
|||
|
||||
def test_buffer(self):
|
||||
for s in ["", "Andrè Previn", "abc", " "*10000]:
|
||||
b = buffer(s)
|
||||
with test_support.check_py3k_warnings(("buffer.. not supported",
|
||||
DeprecationWarning)):
|
||||
b = buffer(s)
|
||||
new = marshal.loads(marshal.dumps(b))
|
||||
self.assertEqual(s, new)
|
||||
marshal.dump(b, file(test_support.TESTFN, "wb"))
|
||||
|
|
|
@ -2023,7 +2023,9 @@ def test_main(run=None):
|
|||
|
||||
loadTestsFromTestCase = unittest.defaultTestLoader.loadTestsFromTestCase
|
||||
suite = unittest.TestSuite(loadTestsFromTestCase(tc) for tc in testcases)
|
||||
run(suite)
|
||||
with test_support.check_py3k_warnings(
|
||||
(".+__(get|set)slice__ has been removed", DeprecationWarning)):
|
||||
run(suite)
|
||||
|
||||
ThreadsMixin.pool.terminate()
|
||||
ProcessesMixin.pool.terminate()
|
||||
|
|
|
@ -192,7 +192,9 @@ class OperatorTestCase(unittest.TestCase):
|
|||
class C:
|
||||
pass
|
||||
def check(self, o, v):
|
||||
self.assertTrue(operator.isCallable(o) == callable(o) == v)
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertEqual(operator.isCallable(o), v)
|
||||
self.assertEqual(callable(o), v)
|
||||
check(self, 4, 0)
|
||||
check(self, operator.isCallable, 1)
|
||||
check(self, C, 1)
|
||||
|
@ -306,8 +308,9 @@ 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))
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertTrue(operator.sequenceIncludes(range(4), 2))
|
||||
self.assertFalse(operator.sequenceIncludes(range(4), 5))
|
||||
|
||||
def test_setitem(self):
|
||||
a = range(3)
|
||||
|
|
|
@ -206,17 +206,20 @@ def test_main(verbose=None):
|
|||
import sys
|
||||
from test import test_support
|
||||
test_classes = (TestTranforms,)
|
||||
test_support.run_unittest(*test_classes)
|
||||
|
||||
# verify reference counting
|
||||
if verbose and hasattr(sys, "gettotalrefcount"):
|
||||
import gc
|
||||
counts = [None] * 5
|
||||
for i in xrange(len(counts)):
|
||||
test_support.run_unittest(*test_classes)
|
||||
gc.collect()
|
||||
counts[i] = sys.gettotalrefcount()
|
||||
print counts
|
||||
with test_support.check_py3k_warnings(
|
||||
("backquote not supported", SyntaxWarning)):
|
||||
test_support.run_unittest(*test_classes)
|
||||
|
||||
# verify reference counting
|
||||
if verbose and hasattr(sys, "gettotalrefcount"):
|
||||
import gc
|
||||
counts = [None] * 5
|
||||
for i in xrange(len(counts)):
|
||||
test_support.run_unittest(*test_classes)
|
||||
gc.collect()
|
||||
counts[i] = sys.gettotalrefcount()
|
||||
print counts
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main(verbose=True)
|
||||
|
|
|
@ -327,7 +327,12 @@ class ListTest(unittest.TestCase):
|
|||
self.assertIs(op(x, y), True)
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(VectorTest, NumberTest, MiscTest, DictTest, ListTest)
|
||||
test_support.run_unittest(VectorTest, NumberTest, MiscTest, ListTest)
|
||||
with test_support.check_py3k_warnings(("dict inequality comparisons "
|
||||
"not supported in 3.x",
|
||||
DeprecationWarning)):
|
||||
test_support.run_unittest(DictTest)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
@ -1345,6 +1345,10 @@ class TestOnlySetsOperator(TestOnlySetsInBinaryOps):
|
|||
self.other = operator.add
|
||||
self.otherIsIterable = False
|
||||
|
||||
def test_ge_gt_le_lt(self):
|
||||
with test_support.check_py3k_warnings():
|
||||
super(TestOnlySetsOperator, self).test_ge_gt_le_lt()
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
class TestOnlySetsTuple(TestOnlySetsInBinaryOps):
|
||||
|
|
|
@ -1,13 +1,11 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
import warnings
|
||||
warnings.filterwarnings("ignore", "the sets module is deprecated",
|
||||
DeprecationWarning, "test\.test_sets")
|
||||
|
||||
import unittest, operator, copy, pickle, random
|
||||
from sets import Set, ImmutableSet
|
||||
from test import test_support
|
||||
|
||||
test_support.import_module("sets", deprecated=True)
|
||||
from sets import Set, ImmutableSet
|
||||
|
||||
empty_set = Set()
|
||||
|
||||
#==============================================================================
|
||||
|
@ -638,6 +636,10 @@ class TestOnlySetsOperator(TestOnlySetsInBinaryOps):
|
|||
self.other = operator.add
|
||||
self.otherIsIterable = False
|
||||
|
||||
def test_ge_gt_le_lt(self):
|
||||
with test_support.check_py3k_warnings():
|
||||
super(TestOnlySetsOperator, self).test_ge_gt_le_lt()
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
class TestOnlySetsTuple(TestOnlySetsInBinaryOps):
|
||||
|
@ -679,20 +681,16 @@ class TestCopying(unittest.TestCase):
|
|||
|
||||
def test_copy(self):
|
||||
dup = self.set.copy()
|
||||
dup_list = list(dup); dup_list.sort()
|
||||
set_list = list(self.set); set_list.sort()
|
||||
self.assertEqual(len(dup), len(self.set))
|
||||
dup_list = sorted(dup)
|
||||
set_list = sorted(self.set)
|
||||
self.assertEqual(len(dup_list), len(set_list))
|
||||
for i in range(len(dup_list)):
|
||||
self.assertTrue(dup_list[i] is set_list[i])
|
||||
for i, el in enumerate(dup_list):
|
||||
self.assertIs(el, set_list[i])
|
||||
|
||||
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()
|
||||
self.assertEqual(len(dup_list), len(set_list))
|
||||
for i in range(len(dup_list)):
|
||||
self.assertEqual(dup_list[i], set_list[i])
|
||||
self.assertSetEqual(dup, self.set)
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
|
@ -712,6 +710,10 @@ class TestCopyingTriple(TestCopying):
|
|||
def setUp(self):
|
||||
self.set = Set(["zero", 0, None])
|
||||
|
||||
def test_copy(self):
|
||||
with test_support.check_py3k_warnings():
|
||||
super(TestCopyingTriple, self).test_copy()
|
||||
|
||||
#------------------------------------------------------------------------------
|
||||
|
||||
class TestCopyingTuple(TestCopying):
|
||||
|
|
|
@ -115,7 +115,8 @@ class SliceTest(unittest.TestCase):
|
|||
tmp.append((i, j, k))
|
||||
|
||||
x = X()
|
||||
x[1:2] = 42
|
||||
with test_support.check_py3k_warnings():
|
||||
x[1:2] = 42
|
||||
self.assertEquals(tmp, [(1, 2, 42)])
|
||||
|
||||
def test_pickle(self):
|
||||
|
|
|
@ -123,8 +123,9 @@ class ThreadableTest:
|
|||
self.server_ready.wait()
|
||||
self.client_ready.set()
|
||||
self.clientSetUp()
|
||||
if not callable(test_func):
|
||||
raise TypeError, "test_func must be a callable function"
|
||||
with test_support.check_py3k_warnings():
|
||||
if not callable(test_func):
|
||||
raise TypeError("test_func must be a callable function.")
|
||||
try:
|
||||
test_func()
|
||||
except Exception, strerror:
|
||||
|
@ -132,7 +133,7 @@ class ThreadableTest:
|
|||
self.clientTearDown()
|
||||
|
||||
def clientSetUp(self):
|
||||
raise NotImplementedError, "clientSetUp must be implemented."
|
||||
raise NotImplementedError("clientSetUp must be implemented.")
|
||||
|
||||
def clientTearDown(self):
|
||||
self.done.set()
|
||||
|
@ -282,8 +283,8 @@ class GeneralModuleTests(unittest.TestCase):
|
|||
orig = sys.getrefcount(__name__)
|
||||
socket.getnameinfo(__name__,0)
|
||||
except TypeError:
|
||||
if sys.getrefcount(__name__) <> orig:
|
||||
self.fail("socket.getnameinfo loses a reference")
|
||||
self.assertEqual(sys.getrefcount(__name__), orig,
|
||||
"socket.getnameinfo loses a reference")
|
||||
|
||||
def testInterpreterCrash(self):
|
||||
# Making sure getnameinfo doesn't crash the interpreter
|
||||
|
@ -1234,7 +1235,8 @@ class BufferIOTest(SocketConnectedTest):
|
|||
self.assertEqual(msg, MSG)
|
||||
|
||||
def _testRecvIntoArray(self):
|
||||
buf = buffer(MSG)
|
||||
with test_support.check_py3k_warnings():
|
||||
buf = buffer(MSG)
|
||||
self.serv_conn.send(buf)
|
||||
|
||||
def testRecvIntoBytearray(self):
|
||||
|
@ -1263,7 +1265,8 @@ class BufferIOTest(SocketConnectedTest):
|
|||
self.assertEqual(msg, MSG)
|
||||
|
||||
def _testRecvFromIntoArray(self):
|
||||
buf = buffer(MSG)
|
||||
with test_support.check_py3k_warnings():
|
||||
buf = buffer(MSG)
|
||||
self.serv_conn.send(buf)
|
||||
|
||||
def testRecvFromIntoBytearray(self):
|
||||
|
|
|
@ -185,7 +185,7 @@ class TestDecorateSortUndecorate(unittest.TestCase):
|
|||
def test_stability(self):
|
||||
data = [(random.randrange(100), i) for i in xrange(200)]
|
||||
copy = data[:]
|
||||
data.sort(key=lambda (x,y): x) # sort on the random first field
|
||||
data.sort(key=lambda x: x[0]) # sort on the random first field
|
||||
copy.sort() # sort using both fields
|
||||
self.assertEqual(data, copy) # should get the same result
|
||||
|
||||
|
@ -207,7 +207,7 @@ class TestDecorateSortUndecorate(unittest.TestCase):
|
|||
# Verify that the wrapper has been removed
|
||||
data = range(-2,2)
|
||||
dup = data[:]
|
||||
self.assertRaises(ZeroDivisionError, data.sort, None, lambda x: 1/x)
|
||||
self.assertRaises(ZeroDivisionError, data.sort, None, lambda x: 1 // x)
|
||||
self.assertEqual(data, dup)
|
||||
|
||||
def test_key_with_mutation(self):
|
||||
|
@ -274,17 +274,19 @@ def test_main(verbose=None):
|
|||
TestBugs,
|
||||
)
|
||||
|
||||
test_support.run_unittest(*test_classes)
|
||||
with test_support.check_py3k_warnings(
|
||||
("the cmp argument is not supported", DeprecationWarning)):
|
||||
test_support.run_unittest(*test_classes)
|
||||
|
||||
# verify reference counting
|
||||
if verbose and hasattr(sys, "gettotalrefcount"):
|
||||
import gc
|
||||
counts = [None] * 5
|
||||
for i in xrange(len(counts)):
|
||||
test_support.run_unittest(*test_classes)
|
||||
gc.collect()
|
||||
counts[i] = sys.gettotalrefcount()
|
||||
print counts
|
||||
# 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)
|
||||
|
|
|
@ -805,7 +805,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))
|
||||
|
@ -967,7 +967,8 @@ else:
|
|||
# now fetch the same data from the HTTPS server
|
||||
url = 'https://127.0.0.1:%d/%s' % (
|
||||
server.port, os.path.split(CERTFILE)[1])
|
||||
f = urllib.urlopen(url)
|
||||
with test_support.check_py3k_warnings():
|
||||
f = urllib.urlopen(url)
|
||||
dlen = f.info().getheader("content-length")
|
||||
if dlen and (int(dlen) > 0):
|
||||
d2 = f.read(int(dlen))
|
||||
|
|
|
@ -552,7 +552,9 @@ class SyntaxTestCase(unittest.TestCase):
|
|||
def test_main():
|
||||
test_support.run_unittest(SyntaxTestCase)
|
||||
from test import test_syntax
|
||||
test_support.run_doctest(test_syntax, verbosity=True)
|
||||
with test_support.check_py3k_warnings(("backquote not supported",
|
||||
SyntaxWarning)):
|
||||
test_support.run_doctest(test_syntax, verbosity=True)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
@ -1,6 +1,7 @@
|
|||
# Python test set -- part 6, built-in types
|
||||
|
||||
from test.test_support import run_unittest, have_unicode, run_with_locale
|
||||
from test.test_support import run_unittest, have_unicode, run_with_locale, \
|
||||
check_py3k_warnings
|
||||
import unittest
|
||||
import sys
|
||||
import locale
|
||||
|
@ -741,7 +742,10 @@ class TypesTests(unittest.TestCase):
|
|||
self.assertRaises(ValueError, format, 0, ',' + code)
|
||||
|
||||
def test_main():
|
||||
run_unittest(TypesTests)
|
||||
with check_py3k_warnings(
|
||||
("buffer.. not supported", DeprecationWarning),
|
||||
("classic long division", DeprecationWarning)):
|
||||
run_unittest(TypesTests)
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_main()
|
||||
|
|
|
@ -1,4 +1,4 @@
|
|||
from test.test_support import run_unittest
|
||||
from test.test_support import run_unittest, check_py3k_warnings
|
||||
import unittest
|
||||
|
||||
class TestImplementationComparisons(unittest.TestCase):
|
||||
|
@ -32,7 +32,8 @@ class TestImplementationComparisons(unittest.TestCase):
|
|||
self.assertTrue(g_cell != h_cell)
|
||||
|
||||
def test_main():
|
||||
run_unittest(TestImplementationComparisons)
|
||||
with check_py3k_warnings():
|
||||
run_unittest(TestImplementationComparisons)
|
||||
|
||||
if __name__ == '__main__':
|
||||
test_main()
|
||||
|
|
|
@ -80,7 +80,8 @@ class TestGenericUnivNewlines(unittest.TestCase):
|
|||
|
||||
def test_execfile(self):
|
||||
namespace = {}
|
||||
execfile(test_support.TESTFN, namespace)
|
||||
with test_support.check_py3k_warnings():
|
||||
execfile(test_support.TESTFN, namespace)
|
||||
func = namespace['line3']
|
||||
self.assertEqual(func.func_code.co_firstlineno, 3)
|
||||
self.assertEqual(namespace['line4'], FATX)
|
||||
|
|
|
@ -45,7 +45,7 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
|
|||
# Test __repr__
|
||||
self.assertEqual(str(u0), str(d0))
|
||||
self.assertEqual(repr(u1), repr(d1))
|
||||
self.assertEqual(`u2`, `d2`)
|
||||
self.assertEqual(repr(u2), repr(d2))
|
||||
|
||||
# Test __cmp__ and __len__
|
||||
all = [d0, d1, d2, u, u0, u1, u2, uu, uu0, uu1, uu2]
|
||||
|
@ -95,12 +95,13 @@ class UserDictTest(mapping_tests.TestHashMappingProtocol):
|
|||
|
||||
# Test has_key and "in".
|
||||
for i in u2.keys():
|
||||
self.assertTrue(u2.has_key(i))
|
||||
self.assertIn(i, 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)
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertTrue(u2.has_key(i))
|
||||
self.assertEqual(u1.has_key(i), d1.has_key(i))
|
||||
self.assertEqual(u0.has_key(i), d0.has_key(i))
|
||||
|
||||
# Test update
|
||||
t = UserDict.UserDict()
|
||||
|
|
|
@ -53,7 +53,9 @@ class UserListTest(list_tests.CommonTest):
|
|||
self.assertEqual(iter(T((1,2))).next(), "0!!!")
|
||||
|
||||
def test_main():
|
||||
test_support.run_unittest(UserListTest)
|
||||
with test_support.check_py3k_warnings(
|
||||
(".+__(get|set|del)slice__ has been removed", DeprecationWarning)):
|
||||
test_support.run_unittest(UserListTest)
|
||||
|
||||
if __name__ == "__main__":
|
||||
test_main()
|
||||
|
|
|
@ -54,10 +54,10 @@ class ReferencesTestCase(TestBase):
|
|||
# Live reference:
|
||||
o = C()
|
||||
wr = weakref.ref(o)
|
||||
`wr`
|
||||
repr(wr)
|
||||
# Dead reference:
|
||||
del o
|
||||
`wr`
|
||||
repr(wr)
|
||||
|
||||
def test_basic_callback(self):
|
||||
self.check_basic_callback(C)
|
||||
|
@ -169,7 +169,8 @@ class ReferencesTestCase(TestBase):
|
|||
p.append(12)
|
||||
self.assertEqual(len(L), 1)
|
||||
self.assertTrue(p, "proxy for non-empty UserList should be true")
|
||||
p[:] = [2, 3]
|
||||
with test_support.check_py3k_warnings():
|
||||
p[:] = [2, 3]
|
||||
self.assertEqual(len(L), 2)
|
||||
self.assertEqual(len(p), 2)
|
||||
self.assertIn(3, p, "proxy didn't support __contains__() properly")
|
||||
|
@ -182,10 +183,11 @@ class ReferencesTestCase(TestBase):
|
|||
## self.assertEqual(repr(L2), repr(p2))
|
||||
L3 = UserList.UserList(range(10))
|
||||
p3 = weakref.proxy(L3)
|
||||
self.assertEqual(L3[:], p3[:])
|
||||
self.assertEqual(L3[5:], p3[5:])
|
||||
self.assertEqual(L3[:5], p3[:5])
|
||||
self.assertEqual(L3[2:5], p3[2:5])
|
||||
with test_support.check_py3k_warnings():
|
||||
self.assertEqual(L3[:], p3[:])
|
||||
self.assertEqual(L3[5:], p3[5:])
|
||||
self.assertEqual(L3[:5], p3[:5])
|
||||
self.assertEqual(L3[2:5], p3[2:5])
|
||||
|
||||
def test_proxy_unicode(self):
|
||||
# See bug 5037
|
||||
|
@ -831,7 +833,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:
|
||||
|
@ -853,8 +855,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.assertIn(o, dict)
|
||||
self.assertNotIn(34, dict)
|
||||
|
||||
def test_weak_keyed_iters(self):
|
||||
dict, objects = self.make_weak_keyed_dict()
|
||||
|
@ -866,7 +868,6 @@ class MappingTestCase(TestBase):
|
|||
objects2 = list(objects)
|
||||
for wr in refs:
|
||||
ob = wr()
|
||||
self.assertTrue(dict.has_key(ob))
|
||||
self.assertIn(ob, dict)
|
||||
self.assertEqual(ob.arg, dict[ob])
|
||||
objects2.remove(ob)
|
||||
|
@ -877,7 +878,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.assertIn(ob, dict)
|
||||
self.assertEqual(ob.arg, dict[ob])
|
||||
objects2.remove(ob)
|
||||
|
@ -991,16 +991,16 @@ class MappingTestCase(TestBase):
|
|||
" -- value parameters must be distinct objects")
|
||||
weakdict = klass()
|
||||
o = weakdict.setdefault(key, value1)
|
||||
self.assertTrue(o is value1)
|
||||
self.assertTrue(weakdict.has_key(key))
|
||||
self.assertTrue(weakdict.get(key) is value1)
|
||||
self.assertTrue(weakdict[key] is value1)
|
||||
self.assertIs(o, value1)
|
||||
self.assertIn(key, weakdict)
|
||||
self.assertIs(weakdict.get(key), value1)
|
||||
self.assertIs(weakdict[key], value1)
|
||||
|
||||
o = weakdict.setdefault(key, value2)
|
||||
self.assertTrue(o is value1)
|
||||
self.assertTrue(weakdict.has_key(key))
|
||||
self.assertTrue(weakdict.get(key) is value1)
|
||||
self.assertTrue(weakdict[key] is value1)
|
||||
self.assertIs(o, value1)
|
||||
self.assertIn(key, weakdict)
|
||||
self.assertIs(weakdict.get(key), value1)
|
||||
self.assertIs(weakdict[key], value1)
|
||||
|
||||
def test_weak_valued_dict_setdefault(self):
|
||||
self.check_setdefault(weakref.WeakValueDictionary,
|
||||
|
@ -1012,24 +1012,24 @@ class MappingTestCase(TestBase):
|
|||
|
||||
def check_update(self, klass, dict):
|
||||
#
|
||||
# This exercises d.update(), len(d), d.keys(), d.has_key(),
|
||||
# This exercises d.update(), len(d), d.keys(), in d,
|
||||
# d.get(), d[].
|
||||
#
|
||||
weakdict = klass()
|
||||
weakdict.update(dict)
|
||||
self.assertTrue(len(weakdict) == len(dict))
|
||||
self.assertEqual(len(weakdict), len(dict))
|
||||
for k in weakdict.keys():
|
||||
self.assertTrue(dict.has_key(k),
|
||||
self.assertIn(k, 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))
|
||||
self.assertIs(v, weakdict[k])
|
||||
self.assertIs(v, weakdict.get(k))
|
||||
for k in dict.keys():
|
||||
self.assertTrue(weakdict.has_key(k),
|
||||
self.assertIn(k, weakdict,
|
||||
"original key disappeared in weak dict")
|
||||
v = dict[k]
|
||||
self.assertTrue(v is weakdict[k])
|
||||
self.assertTrue(v is weakdict.get(k))
|
||||
self.assertIs(v, weakdict[k])
|
||||
self.assertIs(v, weakdict.get(k))
|
||||
|
||||
def test_weak_valued_dict_update(self):
|
||||
self.check_update(weakref.WeakValueDictionary,
|
||||
|
|
|
@ -13,6 +13,7 @@ import doctest
|
|||
import inspect
|
||||
import linecache
|
||||
import pdb
|
||||
import warnings
|
||||
from test.script_helper import (spawn_python, kill_python, run_python,
|
||||
temp_dir, make_script, make_zip_script)
|
||||
|
||||
|
@ -166,8 +167,15 @@ class ZipSupportTests(ImportHooksBaseTestCase):
|
|||
test_zipped_doctest.test_testfile,
|
||||
test_zipped_doctest.test_unittest_reportflags,
|
||||
]
|
||||
for obj in known_good_tests:
|
||||
_run_object_doctest(obj, test_zipped_doctest)
|
||||
# Needed for test_DocTestParser and test_debug
|
||||
with test.test_support.check_py3k_warnings(
|
||||
("backquote not supported", SyntaxWarning),
|
||||
("execfile.. not supported", DeprecationWarning)):
|
||||
# Ignore all warnings about the use of class Tester in this module.
|
||||
warnings.filterwarnings("ignore", "class Tester is deprecated",
|
||||
DeprecationWarning)
|
||||
for obj in known_good_tests:
|
||||
_run_object_doctest(obj, test_zipped_doctest)
|
||||
|
||||
def test_doctest_main_issue4197(self):
|
||||
test_src = textwrap.dedent("""\
|
||||
|
|
Loading…
Reference in New Issue