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, \
+ check_warnings
from test.test_support import TestSkipped, run_unittest, reap_children, import_module
-
# Silence Py3k warning
import_module('commands', deprecated=True)
from commands import *
/\. # and end with the name of the file.
'''
- self.assert_(re.match(pat, getstatus("/."), re.VERBOSE))
+ with check_warnings((".*commands.getstatus.. is deprecated",
+ DeprecationWarning),
+ ("in 3.x, mkarg has been removed",
+ DeprecationWarning),):
+ self.assertTrue(re.match(pat, 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
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.assertEquals(atan2(z2.imag, -1.), atan2(-0., -1.))
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 sys
import os
import decimal
with nested(a(), b()) as (x, y):
state.append(x)
state.append(y)
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.assertEqual(state, [1, 4, 2, 5, 6, 3])
else:
pass
try:
with nested(a(), b()) as (x, y):
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.assertEqual((x, y), (1, 2))
except Exception:
pass
try:
with nested(a(), b()):
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.fail("Didn't swallow ZeroDivisionError")
try:
with closing(x) as y:
self.assertEqual(x, y)
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.assertEqual(state, [1])
else:
with open(tfn, "r") as f:
self.failIf(f.closed)
self.assertEqual(f.read(), "Booh\n")
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.failUnless(f.closed)
else:
try:
with lock:
self.failUnless(locked())
- 1/0
+ 1 // 0
except ZeroDivisionError:
self.failIf(locked())
else:
def test_main():
test_support.run_unittest(__name__)
+
if __name__ == "__main__":
test_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()
def test_main():
with _check_py3k_warnings(("buffer.. not supported", DeprecationWarning),
- ("classic (int|long) division", 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]
import __builtin__
+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),
- (".+__(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:
- 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
self.assertRaises(AttributeError, getattr, exc, "message")
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()
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
-from itertools import chain, cycle
+from itertools import cycle, count
from test import test_support
import codecs
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):
-import sys
-sys.path = ['.'] + sys.path
-
-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, os, 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():
+ with test_support.check_warnings(quiet=True):
import CGIHTTPServer
import audiodev
import bdb
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)
with test_support.check_warnings(('foo', UserWarning)):
wmod.warn("foo")
- with self.assertRaises(AssertionError):
+ try:
with test_support.check_warnings(('', RuntimeWarning)):
# defaults to quiet=False with argument
pass
- with self.assertRaises(AssertionError):
+ except AssertionError:
+ pass
+ else:
+ self.fail("Dind't raise AssertionError")
+ try:
with test_support.check_warnings(('foo', RuntimeWarning)):
wmod.warn("foo")
-
+ except AssertionError:
+ pass
+ else:
+ self.fail("Dind't raise AssertionError")
class CCatchWarningTests(CatchWarningTests):
module = c_warnings
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