from test import test_support as support
import os
import sys
-import warnings
class NoAll(RuntimeError):
def check_all(self, modname):
names = {}
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", ".* (module|package)",
- DeprecationWarning)
+ with support.check_warnings((".* (module|package)",
+ DeprecationWarning), quiet=True):
try:
exec "import %s" % modname in names
except:
import textwrap
import tempfile
import unittest
-import warnings
import argparse
from StringIO import StringIO
self.assertTrue(hasattr(argparse, name))
def test_main():
- with warnings.catch_warnings():
- # silence warnings about version argument - these are expected
- warnings.filterwarnings(
- action='ignore',
- message='The "version" argument to ArgumentParser is deprecated.',
- category=DeprecationWarning)
- warnings.filterwarnings(
- action='ignore',
- message='The format_version method is deprecated',
- category=DeprecationWarning)
- warnings.filterwarnings(
- action='ignore',
- message='The print_version method is deprecated',
- category=DeprecationWarning)
-
+ # silence warnings about version argument - these are expected
+ with test_support.check_warnings(
+ ('The "version" argument to ArgumentParser is deprecated.',
+ DeprecationWarning),
+ ('The (format|print)_version method is deprecated',
+ DeprecationWarning)):
test_support.run_unittest(__name__)
# Remove global references to avoid looking like we have refleaks.
RFile.seen = {}
import copy
-import warnings
import unittest
-from test.test_support import run_unittest, TestFailed
+from test.test_support import run_unittest, TestFailed, check_warnings
# Fake a number that implements numeric methods through __coerce__
class CoerceNumber:
infix_results[key] = res
-with warnings.catch_warnings():
- warnings.filterwarnings("ignore", "classic int division",
- DeprecationWarning)
- process_infix_results()
-# now infix_results has two lists of results for every pairing.
-
prefix_binops = [ 'divmod' ]
prefix_results = [
[(1,0), (1L,0L), (0.0,2.0), ((1+0j),0j), TE, TE, TE, TE, (1,0)],
raise exc
def test_main():
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", "complex divmod.., // and % "
- "are deprecated", DeprecationWarning)
- warnings.filterwarnings("ignore", "classic (int|long) division",
- DeprecationWarning)
+ with check_warnings(("complex divmod.., // and % are deprecated",
+ DeprecationWarning),
+ ("classic (int|long) division", DeprecationWarning),
+ quiet=True):
+ process_infix_results()
+ # now infix_results has two lists of results for every pairing.
+
run_unittest(CoercionTest)
if __name__ == "__main__":
'''
import unittest
import os, tempfile, re
-import warnings
-warnings.filterwarnings('ignore', r".*commands.getstatus.. is deprecated",
- DeprecationWarning)
-
-from test.test_support import run_unittest, reap_children, import_module
+from test.test_support import run_unittest, reap_children, import_module, \
+ check_warnings
# Silence Py3k warning
commands = import_module('commands', deprecated=True)
/\. # and end with the name of the file.
'''
- self.assertTrue(re.match(pat, commands.getstatus("/."), re.VERBOSE))
+ with check_warnings((".*commands.getstatus.. is deprecated",
+ DeprecationWarning)):
+ self.assertTrue(re.match(pat, commands.getstatus("/."), re.VERBOSE))
def test_main():
-import unittest, os
+import unittest
from test import test_support
-import warnings
-warnings.filterwarnings(
- "ignore",
- category=DeprecationWarning,
- message=".*complex divmod.*are deprecated"
-)
-
from random import random
from math import atan2, isnan, copysign
finally:
if (fo is not None) and (not fo.closed):
fo.close()
- try:
- os.remove(test_support.TESTFN)
- except (OSError, IOError):
- pass
+ test_support.unlink(test_support.TESTFN)
def test_getnewargs(self):
self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
self.assertEqual('{0:F}'.format(complex(NAN, NAN)), 'NAN+NANj')
def test_main():
- test_support.run_unittest(ComplexTest)
+ with test_support.check_warnings(("complex divmod.., // and % are "
+ "deprecated", DeprecationWarning)):
+ test_support.run_unittest(ComplexTest)
if __name__ == "__main__":
test_main()
"""Unit tests for contextlib.py, and other context managers."""
-
-import os
import sys
import tempfile
import unittest
import threading
from contextlib import * # Tests __all__
from test import test_support
-import warnings
+
class ContextManagerTestCase(unittest.TestCase):
yield 42
finally:
state.append(999)
- try:
+ with self.assertRaises(ZeroDivisionError):
with woohoo() as x:
self.assertEqual(state, [1])
self.assertEqual(x, 42)
state.append(x)
raise ZeroDivisionError()
- except ZeroDivisionError:
- pass
- else:
- self.fail("Expected ZeroDivisionError")
self.assertEqual(state, [1, 42, 999])
def test_contextmanager_no_reraise(self):
yield 5
finally:
state.append(6)
- try:
+ with self.assertRaises(ZeroDivisionError):
with nested(a(), b()) as (x, y):
state.append(x)
state.append(y)
- 1/0
- except ZeroDivisionError:
- self.assertEqual(state, [1, 4, 2, 5, 6, 3])
- else:
- self.fail("Didn't raise ZeroDivisionError")
+ 1 // 0
+ self.assertEqual(state, [1, 4, 2, 5, 6, 3])
def test_nested_right_exception(self):
@contextmanager
raise Exception()
except:
pass
- try:
+ with self.assertRaises(ZeroDivisionError):
with nested(a(), b()) as (x, y):
- 1/0
- except ZeroDivisionError:
- self.assertEqual((x, y), (1, 2))
- except Exception:
- self.fail("Reraised wrong exception")
- else:
- self.fail("Didn't raise ZeroDivisionError")
+ 1 // 0
+ self.assertEqual((x, y), (1, 2))
def test_nested_b_swallows(self):
@contextmanager
pass
try:
with nested(a(), b()):
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.fail("Didn't swallow ZeroDivisionError")
state.append(1)
x = C()
self.assertEqual(state, [])
- try:
+ with self.assertRaises(ZeroDivisionError):
with closing(x) as y:
self.assertEqual(x, y)
- 1/0
- except ZeroDivisionError:
- self.assertEqual(state, [1])
- else:
- self.fail("Didn't raise ZeroDivisionError")
+ 1 // 0
+ self.assertEqual(state, [1])
class FileContextTestCase(unittest.TestCase):
f.write("Booh\n")
self.assertTrue(f.closed)
f = None
- try:
+ with self.assertRaises(ZeroDivisionError):
with open(tfn, "r") as f:
self.assertFalse(f.closed)
self.assertEqual(f.read(), "Booh\n")
- 1/0
- except ZeroDivisionError:
- self.assertTrue(f.closed)
- else:
- self.fail("Didn't raise ZeroDivisionError")
+ 1 // 0
+ self.assertTrue(f.closed)
finally:
- try:
- os.remove(tfn)
- except os.error:
- pass
+ test_support.unlink(tfn)
class LockContextTestCase(unittest.TestCase):
with lock:
self.assertTrue(locked())
self.assertFalse(locked())
- try:
+ with self.assertRaises(ZeroDivisionError):
with lock:
self.assertTrue(locked())
- 1/0
- except ZeroDivisionError:
- self.assertFalse(locked())
- else:
- self.fail("Didn't raise ZeroDivisionError")
+ 1 // 0
+ self.assertFalse(locked())
def testWithLock(self):
lock = threading.Lock()
# This is needed to make the test actually run under regrtest.py!
def test_main():
- with warnings.catch_warnings():
- warnings.simplefilter('ignore')
+ with test_support.check_warnings(("With-statements now directly support "
+ "multiple context managers",
+ DeprecationWarning)):
test_support.run_unittest(__name__)
if __name__ == "__main__":
# Simple test suite for Cookie.py
-from test.test_support import run_unittest, run_doctest
+from test.test_support import run_unittest, run_doctest, check_warnings
import unittest
import Cookie
-import warnings
-warnings.filterwarnings("ignore",
- ".* class is insecure.*",
- DeprecationWarning)
class CookieTests(unittest.TestCase):
# Currently this only tests SimpleCookie
def test_main():
run_unittest(CookieTests)
- run_doctest(Cookie)
+ with check_warnings(('.+Cookie class is insecure; do not use it',
+ DeprecationWarning)):
+ run_doctest(Cookie)
if __name__ == '__main__':
test_main()
import sys
import types
import unittest
-import warnings
from copy import deepcopy
from test import test_support
expr = '%s a' % expr
self.unops[name] = expr
- def setUp(self):
- self.original_filters = warnings.filters[:]
- warnings.filterwarnings("ignore",
- r'complex divmod\(\), // and % are deprecated$',
- DeprecationWarning, r'(<string>|%s)$' % __name__)
-
- def tearDown(self):
- warnings.filters = self.original_filters
-
def unop_test(self, a, res, expr="len(a)", meth="__len__"):
d = {'a': a}
self.assertEqual(eval(expr, d), res)
def test_main():
- with test_support.check_py3k_warnings(
+ deprecations = [(r'complex divmod\(\), // and % are deprecated$',
+ DeprecationWarning)]
+ if sys.py3kwarning:
+ deprecations += [
("classic (int|long) division", DeprecationWarning),
("coerce.. not supported", DeprecationWarning),
("Overriding __cmp__ ", DeprecationWarning),
- (".+__(get|set|del)slice__ has been removed", DeprecationWarning)):
+ (".+__(get|set|del)slice__ has been removed", DeprecationWarning)]
+ with test_support.check_warnings(*deprecations):
# Run all local test cases, with PTypesLongInitTest first.
test_support.run_unittest(PTypesLongInitTest, OperatorsTest,
ClassPropertiesAndMethods, DictProxyTests)
Test script for doctest.
"""
+import sys
from test import test_support
import doctest
-import warnings
# NOTE: There are some additional tests relating to interaction with
# zipimport in the test_zipimport_support test module.
test_support.run_doctest(doctest, verbosity=True)
from test import test_doctest
- 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)
+
+ # Ignore all warnings about the use of class Tester in this module.
+ deprecations = [("class Tester is deprecated", DeprecationWarning)]
+ if sys.py3kwarning:
+ deprecations += [("backquote not supported", SyntaxWarning),
+ ("execfile.. not supported", DeprecationWarning)]
+ with test_support.check_warnings(*deprecations):
# Check the doctest cases defined here:
test_support.run_doctest(test_doctest, verbosity=True)
import sys
import unittest
import pickle, cPickle
-import warnings
-from test.test_support import TESTFN, unlink, run_unittest, captured_output
+from test.test_support import (TESTFN, unlink, run_unittest, captured_output,
+ check_warnings)
from test.test_pep352 import ignore_deprecation_warnings
# XXX This is not really enough, each *operation* should be tested!
# Accessing BaseException.message and relying on its value set by
# BaseException.__init__ triggers a deprecation warning.
exc = BaseException("foo")
- with warnings.catch_warnings(record=True) as w:
- warnings.simplefilter('default')
- self.assertEquals(exc.message, "foo")
- self.assertEquals(len(w), 1)
- self.assertEquals(w[0].category, DeprecationWarning)
- self.assertEquals(
- str(w[0].message),
- "BaseException.message has been deprecated as of Python 2.6")
-
+ with check_warnings(("BaseException.message has been deprecated "
+ "as of Python 2.6", DeprecationWarning)) as w:
+ self.assertEqual(exc.message, "foo")
+ self.assertEqual(len(w.warnings), 1)
def testRegularMessageAttribute(self):
# Accessing BaseException.message after explicitly setting a value
# for it does not trigger a deprecation warning.
exc = BaseException("foo")
exc.message = "bar"
- with warnings.catch_warnings(record=True) as w:
- self.assertEquals(exc.message, "bar")
- self.assertEquals(len(w), 0)
+ with check_warnings(quiet=True) as w:
+ self.assertEqual(exc.message, "bar")
+ self.assertEqual(len(w.warnings), 0)
# Deleting the message is supported, too.
del exc.message
with self.assertRaises(AttributeError):
from test.test_support import run_unittest, check_syntax_error
import unittest
-
import warnings
-warnings.filterwarnings("error", module="<test string>")
+
class GlobalTests(unittest.TestCase):
def test_main():
- run_unittest(GlobalTests)
+ with warnings.catch_warnings():
+ warnings.filterwarnings("error", module="<test string>")
+ run_unittest(GlobalTests)
if __name__ == "__main__":
test_main()
with warnings.catch_warnings():
warnings.simplefilter('error', RuntimeWarning)
- try:
+ with self.assertRaises(RuntimeWarning):
hmac.HMAC('a', 'b', digestmod=MockCrazyHash)
- except RuntimeWarning:
- pass
- else:
self.fail('Expected warning about missing block_size')
MockCrazyHash.block_size = 1
- try:
+ with self.assertRaises(RuntimeWarning):
hmac.HMAC('a', 'b', digestmod=MockCrazyHash)
- except RuntimeWarning:
- pass
- else:
self.fail('Expected warning about small block_size')
import unittest
from test import test_support
-import warnings
-warnings.filterwarnings("ignore", "hex/oct constants", FutureWarning,
- "<string>")
class TestHexOctBin(unittest.TestCase):
import threading
import random
import unittest
-import warnings
import weakref
import abc
from itertools import cycle, count
rfp.close()
def tearDown(self):
- try:
- os.unlink(test_support.TESTFN)
- except:
- pass
- try:
- os.unlink(TESTFN2)
- except:
- pass
+ test_support.unlink(test_support.TESTFN)
+ test_support.unlink(TESTFN2)
def compareData(self):
fp = open(test_support.TESTFN, 'r')
def test_touched(self):
# This really only tests that nothing unforeseen happens.
- import warnings
- with warnings.catch_warnings():
- warnings.filterwarnings('ignore', 'macostools.touched*',
- DeprecationWarning)
+ with test_support.check_warnings(('macostools.touched*',
+ DeprecationWarning), quiet=True):
macostools.touched(test_support.TESTFN)
if sys.maxint < 2**32:
def test_copy(self):
- try:
- os.unlink(TESTFN2)
- except:
- pass
+ test_support.unlink(TESTFN2)
macostools.copy(test_support.TESTFN, TESTFN2)
self.assertEqual(self.compareData(), '')
if sys.maxint < 2**32:
def test_mkalias(self):
- try:
- os.unlink(TESTFN2)
- except:
- pass
+ test_support.unlink(TESTFN2)
macostools.mkalias(test_support.TESTFN, TESTFN2)
fss, _, _ = Carbon.File.ResolveAliasFile(TESTFN2, 0)
self.assertEqual(fss.as_pathname(), os.path.realpath(test_support.TESTFN))
def test_mkalias_relative(self):
- try:
- os.unlink(TESTFN2)
- except:
- pass
+ test_support.unlink(TESTFN2)
# If the directory doesn't exist, then chances are this is a new
# install of Python so don't create it since the user might end up
# running ``sudo make install`` and creating the directory here won't
import __builtin__
import exceptions
import warnings
-from test.test_support import run_unittest
+from test.test_support import run_unittest, check_warnings
import os
import sys
from platform import system as platform_system
"catching classes that don't inherit from BaseException is not allowed",
"__get(item|slice)__ not supported for exception classes"])
+_deprecations = [(msg, DeprecationWarning) for msg in DEPRECATION_WARNINGS]
+
# 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)
+ with check_warnings(*_deprecations, quiet=True):
return func(*args, **kw)
return wrapper
def test_message_deprecation(self):
# As of Python 2.6, BaseException.message is deprecated.
- with warnings.catch_warnings():
- warnings.resetwarnings()
- warnings.filterwarnings('error')
-
- try:
- BaseException().message
- except DeprecationWarning:
- pass
- else:
- self.fail("BaseException.message not deprecated")
+ with check_warnings(("", DeprecationWarning)):
+ BaseException().message
class UsageTests(unittest.TestCase):
warnings.resetwarnings()
warnings.filterwarnings("error")
str_exc = "spam"
- try:
+ with self.assertRaises(DeprecationWarning):
try:
raise StandardError
except str_exc:
pass
- except DeprecationWarning:
- pass
- except StandardError:
- self.fail("catching a string exception did not raise "
- "DeprecationWarning")
+
# Make sure that even if the string exception is listed in a tuple
# that a warning is raised.
- try:
+ with self.assertRaises(DeprecationWarning):
try:
raise StandardError
except (AssertionError, str_exc):
pass
- except DeprecationWarning:
- pass
- except StandardError:
- self.fail("catching a string exception specified in a tuple did "
- "not raise DeprecationWarning")
def test_main():
-from test.test_support import verbose, run_unittest
+from test.test_support import verbose, run_unittest, import_module
import re
from re import Scanner
import sys, traceback
import cPickle
self.pickle_test(cPickle)
# old pickles expect the _compile() reconstructor in sre module
- import warnings
- with warnings.catch_warnings():
- warnings.filterwarnings("ignore", "The sre module is deprecated",
- DeprecationWarning)
- from sre import _compile
+ import_module("sre", deprecated=True)
+ from sre import _compile
def pickle_test(self, pickle):
oldpat = re.compile('a(?:b|(c|e){1,2}?|d)+?(.)')
from test import test_support
import sys
import unittest
-import warnings
class TestUntestedModules(unittest.TestCase):
def test_at_least_import_untested_modules(self):
- with warnings.catch_warnings():
- warnings.simplefilter("ignore")
+ with test_support.check_warnings(quiet=True):
import CGIHTTPServer
import audiodev
import bdb
"""
import symtable
import unittest
-import warnings
from test import test_support
class SymtableTest(unittest.TestCase):
- with warnings.catch_warnings():
- # Ignore warnings about "from blank import *"
- warnings.simplefilter("ignore", SyntaxWarning)
+ with test_support.check_warnings(
+ ("import \* only allowed at module level", SyntaxWarning)):
top = symtable.symtable(TEST_CODE, "?", "exec")
# These correspond to scopes in TEST_CODE
Mine = find_block(top, "Mine")
def test_main():
test_support.requires('network')
- from warnings import filterwarnings, catch_warnings
- with catch_warnings():
- filterwarnings('ignore', '.*urllib\.urlopen.*Python 3.0',
- DeprecationWarning)
+ with test_support.check_py3k_warnings(
+ ("urllib.urlopen.. has been removed", DeprecationWarning)):
test_support.run_unittest(URLTimeoutTest,
urlopenNetworkTests,
urlretrieveNetworkTests)
test_zipped_doctest.test_unittest_reportflags,
]
# Needed for test_DocTestParser and test_debug
- with test.test_support.check_py3k_warnings(
- ("backquote not supported", SyntaxWarning),
- ("execfile.. not supported", DeprecationWarning)):
+ deprecations = [
# Ignore all warnings about the use of class Tester in this module.
- warnings.filterwarnings("ignore", "class Tester is deprecated",
- DeprecationWarning)
+ ("class Tester is deprecated", DeprecationWarning)]
+ if sys.py3kwarning:
+ deprecations += [
+ ("backquote not supported", SyntaxWarning),
+ ("execfile.. not supported", DeprecationWarning)]
+ with test.test_support.check_warnings(*deprecations):
for obj in known_good_tests:
_run_object_doctest(obj, test_zipped_doctest)
projects / python / commitdiff