# regression test, the filterwarnings() call has been added to
# regrtest.py.
-from test.test_support import run_unittest, check_syntax_error
+from test.test_support import check_syntax_error
import unittest
import sys
# testing import *
self.assertEqual((6 < 4 if 0 else 2), 2)
-def test_main():
- run_unittest(TokenTests, GrammarTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
# regression test, the filterwarnings() call has been added to
# regrtest.py.
-from test.support import run_unittest, check_syntax_error
+from test.support import check_syntax_error
import unittest
import sys
# testing import *
self.assertEqual((6 < 4 if 0 else 2), 2)
-def test_main():
- run_unittest(TokenTests, GrammarTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
# Decorator for running a function in a different locale, correctly resetting
# it afterwards.
+@contextlib.contextmanager
def run_with_locale(catstr, *locales):
- def decorator(func):
- def inner(*args, **kwds):
try:
import locale
category = getattr(locale, catstr)
except:
pass
- # now run the function, resetting the locale on exceptions
try:
- return func(*args, **kwds)
+ yield
finally:
if locale and orig_locale:
locale.setlocale(category, orig_locale)
- inner.__name__ = func.__name__
- inner.__doc__ = func.__doc__
- return inner
- return decorator
#=======================================================================
# Decorator for running a function in a specific timezone, correctly
self.parser.parse_args('--integers a'.split())
-def test_main():
- support.run_unittest(__name__)
+def tearDownModule():
# Remove global references to avoid looking like we have refleaks.
RFile.seen = {}
WFile.seen = set()
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
with TracerRun(self) as tracer:
tracer.runcall(tfunc_import)
-def test_main():
- test.support.run_unittest(
- StateTestCase,
- RunTestCase,
- BreakpointTestCase,
- IssuesTestCase,
- )
if __name__ == "__main__":
- test_main()
+ unittest.main()
x = None
-def test_main():
- support.run_unittest(BytesTest, StrTest)
-
if __name__ == '__main__':
if len(sys.argv) > 1:
support.set_memlimit(sys.argv[1])
- test_main()
+ unittest.main()
self.assertEqual(l[:10], [1] * 10)
self.assertEqual(l[-10:], [5] * 10)
-def test_main():
- support.run_unittest(StrTest, BytesTest, BytearrayTest,
- TupleTest, ListTest)
if __name__ == '__main__':
if len(sys.argv) > 1:
support.set_memlimit(sys.argv[1])
- test_main()
+ unittest.main()
self.assertIs(type(False.real), int)
self.assertIs(type(False.imag), int)
-def test_main():
- support.run_unittest(BoolTest)
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(f.readlines(), [text])
-def test_main():
- support.run_unittest(
- BZ2FileTest,
- BZ2CompressorTest,
- BZ2DecompressorTest,
- CompressDecompressTest,
- OpenTest,
- )
+def tearDownModule():
support.reap_children()
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertEqual(cmd.stdout.rstrip(), loc)
-def test_main():
- support.run_unittest(
- LocaleConfigurationTests,
- LocaleCoercionTests
- )
+def tearDownModule():
support.reap_children()
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
)
-def test_main():
- support.run_unittest(CmdLineTest, IgnoreEnvironmentTest)
+def tearDownModule():
support.reap_children()
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertNotEqual(proc.returncode, 0)
-def test_main():
- support.run_unittest(CmdLineTest)
+def tearDownModule():
support.reap_children()
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j')
self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j')
-def test_main():
- support.run_unittest(ComplexTest)
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(f.exception(), e)
-_threads_key = None
-
def setUpModule():
- global _threads_key
- _threads_key = support.threading_setup()
-
-
-def tearDownModule():
- support.threading_cleanup(*_threads_key)
- multiprocessing.util._cleanup_tests()
+ unittest.addModuleCleanup(multiprocessing.util._cleanup_tests)
+ thread_info = support.threading_setup()
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
if __name__ == "__main__":
self.assertIn('{!r}: {!r}'.format(k, v), r)
-class PTypesLongInitTest(unittest.TestCase):
+class AAAPTypesLongInitTest(unittest.TestCase):
# This is in its own TestCase so that it can be run before any other tests.
+ # (Hence the 'AAA' in the test class name: to make it the first
+ # item in a list sorted by name, like
+ # unittest.TestLoader.getTestCaseNames() does.)
def test_pytype_long_ready(self):
# Testing SF bug 551412 ...
pass
-def test_main():
- # Run all local test cases, with PTypesLongInitTest first.
- support.run_unittest(PTypesLongInitTest, OperatorsTest,
- ClassPropertiesAndMethods, DictProxyTests,
- MiscTests, PicklingTests, SharedKeyTests,
- MroTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import random
import select
import unittest
-from test.support import run_unittest, cpython_only
+from test.support import cpython_only
if not hasattr(select, 'devpoll') :
raise unittest.SkipTest('test works only on Solaris OS family')
self.assertRaises(OverflowError, pollster.modify, 1, USHRT_MAX + 1)
-def test_main():
- run_unittest(DevPollTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import difflib
-from test.support import run_unittest, findfile
+from test.support import findfile
import unittest
import doctest
import sys
self.assertFalse(self.longer_match_exists(a, b, match.size))
-def test_main():
+def setUpModule():
difflib.HtmlDiff._default_prefix = 0
- Doctests = doctest.DocTestSuite(difflib)
- run_unittest(
- TestWithAscii, TestAutojunk, TestSFpatches, TestSFbugs,
- TestOutputFormat, TestBytes, TestJunkAPIs, TestFindLongest, Doctests)
+
+
+def load_tests(loader, tests, pattern):
+ tests.addTest(doctest.DocTestSuite(difflib))
+ return tests
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
import test.support
-def test_main():
- # used by regrtest
- test.support.run_unittest(distutils.tests.test_suite())
- test.support.reap_children()
-
-
def load_tests(*_):
# used by unittest
return distutils.tests.test_suite()
+def tearDownModule():
+ test.support.reap_children()
+
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
import types
import unittest
-from test.support import findfile, run_unittest
+from test.support import findfile
def abspath(filename):
COMMAND = ["stap", "-g"]
-class TraceTests(unittest.TestCase):
+class TraceTests:
# unittest.TestCase options
maxDiff = None
self.run_case("line")
-class DTraceNormalTests(TraceTests):
+class DTraceNormalTests(TraceTests, unittest.TestCase):
backend = DTraceBackend()
optimize_python = 0
-class DTraceOptimizedTests(TraceTests):
+class DTraceOptimizedTests(TraceTests, unittest.TestCase):
backend = DTraceBackend()
optimize_python = 2
-class SystemTapNormalTests(TraceTests):
+class SystemTapNormalTests(TraceTests, unittest.TestCase):
backend = SystemTapBackend()
optimize_python = 0
-class SystemTapOptimizedTests(TraceTests):
+class SystemTapOptimizedTests(TraceTests, unittest.TestCase):
backend = SystemTapBackend()
optimize_python = 2
-def test_main():
- run_unittest(DTraceNormalTests, DTraceOptimizedTests, SystemTapNormalTests,
- SystemTapOptimizedTests)
-
-
if __name__ == '__main__':
test_main()
import sys
import unittest
from multiprocessing import Process
-from test.support import (verbose, TESTFN, unlink, run_unittest, import_module,
+from test.support import (verbose, TESTFN, unlink, import_module,
cpython_only)
# Skip test if no fcntl module.
res = fcntl.fcntl(self.f.fileno(), fcntl.F_GETPATH, bytes(len(expected)))
self.assertEqual(expected, res)
-def test_main():
- run_unittest(TestFcntl)
if __name__ == '__main__':
- test_main()
+ unittest.main()
self.assertEqual(report_lines, expected_report_lines)
-def test_main():
- support.run_unittest(FileCompareTestCase, DirCompareTestCase)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
from weakref import proxy
from functools import wraps
-from test.support import (TESTFN, TESTFN_UNICODE, check_warnings, run_unittest,
+from test.support import (TESTFN, TESTFN_UNICODE, check_warnings,
make_bad_fd, cpython_only, swap_attr, gc_collect)
from collections import UserList
self.assertNotEqual(w.warnings, [])
-def test_main():
+def tearDownModule():
# Historically, these tests have been sloppy about removing TESTFN.
# So get rid of it no matter what.
- try:
- run_unittest(CAutoFileTests, PyAutoFileTests,
- COtherFileTests, PyOtherFileTests)
- finally:
- if os.path.exists(TESTFN):
- os.unlink(TESTFN)
+ if os.path.exists(TESTFN):
+ os.unlink(TESTFN)
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
import os
import threading
import time
+import unittest
try:
import ssl
except ImportError:
support.check__all__(self, ftplib, blacklist=blacklist)
-def test_main():
- tests = [TestFTPClass, TestTimeouts,
- TestIPv6Environment,
- TestTLS_FTPClassMixin, TestTLS_FTPClass,
- MiscTestCase]
-
+def setUpModule():
thread_info = support.threading_setup()
- try:
- support.run_unittest(*tests)
- finally:
- support.threading_cleanup(*thread_info)
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
if __name__ == '__main__':
- test_main()
+ unittest.main()
import unittest
import unittest.mock
-from test.support import (verbose, refcount_test, run_unittest,
+from test.support import (verbose, refcount_test,
cpython_only, start_threads,
temp_dir, TESTFN, unlink,
import_module)
assert_python_ok("-c", code)
-def test_main():
+def setUpModule():
+ global enabled, debug
enabled = gc.isenabled()
gc.disable()
assert not gc.isenabled()
debug = gc.get_debug()
gc.set_debug(debug & ~gc.DEBUG_LEAK) # this test is supposed to leak
+ gc.collect() # Delete 2nd generation garbage
+
+
+def tearDownModule():
+ gc.set_debug(debug)
+ # test gc.enable() even if GC is disabled by default
+ if verbose:
+ print("restoring automatic collection")
+ # make sure to always test gc.enable()
+ gc.enable()
+ assert gc.isenabled()
+ if not enabled:
+ gc.disable()
- try:
- gc.collect() # Delete 2nd generation garbage
- run_unittest(
- GCTests,
- GCCallbackTests,
- GCTogglingTests,
- PythonFinalizationTests)
- finally:
- gc.set_debug(debug)
- # test gc.enable() even if GC is disabled by default
- if verbose:
- print("restoring automatic collection")
- # make sure to always test gc.enable()
- gc.enable()
- assert gc.isenabled()
- if not enabled:
- gc.disable()
if __name__ == "__main__":
- test_main()
+ unittest.main()
"""Verify that warnings are issued for global statements following use."""
-from test.support import run_unittest, check_syntax_error, check_warnings
+from test.support import check_syntax_error, check_warnings
import unittest
import warnings
compile(prog_text_4, "<test string>", "exec")
-def test_main():
- with warnings.catch_warnings():
- warnings.filterwarnings("error", module="<test string>")
- run_unittest(GlobalTests)
+def setUpModule():
+ cm = warnings.catch_warnings()
+ cm.__enter__()
+ unittest.addModuleCleanup(cm.__exit__, None, None, None)
+ warnings.filterwarnings("error", module="<test string>")
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(out, b'')
-def test_main(verbose=None):
- support.run_unittest(TestGzip, TestOpen, TestCommandLine)
-
-
if __name__ == "__main__":
- test_main(verbose=True)
+ unittest.main()
self.assertEqual(mock_server.address_family, socket.AF_INET)
-def test_main(verbose=None):
- cwd = os.getcwd()
- try:
- support.run_unittest(
- RequestHandlerLoggingTestCase,
- BaseHTTPRequestHandlerTestCase,
- BaseHTTPServerTestCase,
- SimpleHTTPServerTestCase,
- CGIHTTPServerTestCase,
- SimpleHTTPRequestHandlerTestCase,
- MiscTestCase,
- ScriptTestCase
- )
- finally:
- os.chdir(cwd)
+def setUpModule():
+ unittest.addModuleCleanup(os.chdir, os.getcwd())
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
import sys
import threading
+import unittest
import weakref
from test import support
) = test_util.test_both(LifetimeTests, init=init)
-@support.reap_threads
-def test_main():
- support.run_unittest(Frozen_ModuleLockAsRLockTests,
- Source_ModuleLockAsRLockTests,
- Frozen_DeadlockAvoidanceTests,
- Source_DeadlockAvoidanceTests,
- Frozen_LifetimeTests,
- Source_LifetimeTests)
+def setUpModule():
+ thread_info = support.threading_setup()
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
if __name__ == '__main__':
- test_main()
+ unittets.main()
import threading
import unittest
from unittest import mock
+from test import support
from test.support import (
- verbose, run_unittest, TESTFN, reap_threads,
+ verbose, TESTFN,
forget, unlink, rmtree, start_threads, script_helper)
def task(N, done, done_tasks, errors):
script_helper.assert_python_ok(fn)
-@reap_threads
-def test_main():
- old_switchinterval = None
+def setUpModule():
+ thread_info = support.threading_setup()
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
try:
old_switchinterval = sys.getswitchinterval()
+ unittest.addModuleCleanup(sys.setswitchinterval, old_switchinterval)
sys.setswitchinterval(1e-5)
except AttributeError:
pass
- try:
- run_unittest(ThreadedImportTests)
- finally:
- if old_switchinterval is not None:
- sys.setswitchinterval(old_switchinterval)
+
if __name__ == "__main__":
- test_main()
+ unittets.main()
except ImportError:
ThreadPoolExecutor = None
-from test.support import run_unittest, TESTFN, DirsOnSysPath, cpython_only
+from test.support import TESTFN, DirsOnSysPath, cpython_only
from test.support import MISSING_C_DOCSTRINGS, ALWAYS_EQ
from test.support.script_helper import assert_python_ok, assert_python_failure
from test import inspect_fodder as mod
self.assertInspectEqual(path, module)
-def test_main():
- run_unittest(
- TestDecorators, TestRetrievingSourceCode, TestOneliners, TestBlockComments,
- TestBuggyCases, TestInterpreterStack, TestClassesAndFunctions, TestPredicates,
- TestGetcallargsFunctions, TestGetcallargsMethods,
- TestGetcallargsUnboundMethods, TestGetattrStatic, TestGetGeneratorState,
- TestNoEOL, TestSignatureObject, TestSignatureBind, TestParameterObject,
- TestBoundArguments, TestSignaturePrivateHelpers,
- TestSignatureDefinitions, TestIsDataDescriptor,
- TestGetClosureVars, TestUnwrap, TestMain, TestReload,
- TestGetCoroutineState, TestGettingSourceOfToplevelFrames
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import sys
import unittest
-from test.support import run_unittest, TESTFN, unlink, cpython_only
+from test.support import TESTFN, unlink, cpython_only
from test.support import check_free_after_iterating, ALWAYS_EQ, NEVER_EQ
import pickle
import collections.abc
self.assertRaises(ZeroDivisionError, iter, BadIterableClass())
-def test_main():
- run_unittest(TestCase)
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
# Set the locale to the platform-dependent default. I have no idea
# why the test does this, but in any case we save the current locale
# first and restore it at the end.
-@support.run_with_locale('LC_ALL', '')
-def test_main():
- tests = [
- BuiltinLevelsTest, BasicFilterTest, CustomLevelsAndFiltersTest,
- HandlerTest, MemoryHandlerTest, ConfigFileTest, SocketHandlerTest,
- DatagramHandlerTest, MemoryTest, EncodingTest, WarningsTest,
- ConfigDictTest, ManagerTest, FormatterTest, BufferingFormatterTest,
- StreamHandlerTest, LogRecordFactoryTest, ChildLoggerTest,
- QueueHandlerTest, ShutdownTest, ModuleLevelMiscTest, BasicConfigTest,
- LoggerAdapterTest, LoggerTest, SMTPHandlerTest, FileHandlerTest,
- RotatingFileHandlerTest, LastResortTest, LogRecordTest,
- ExceptionTest, SysLogHandlerTest, IPv6SysLogHandlerTest, HTTPHandlerTest,
- NTEventLogHandlerTest, TimedRotatingFileHandlerTest,
- UnixSocketHandlerTest, UnixDatagramHandlerTest, UnixSysLogHandlerTest,
- MiscTestCase
- ]
- if hasattr(logging.handlers, 'QueueListener'):
- tests.append(QueueListenerTest)
- support.run_unittest(*tests)
+def setUpModule():
+ cm = support.run_with_locale('LC_ALL', '')
+ cm.__enter__()
+ unittest.addModuleCleanup(cm.__exit__, None, None, None)
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unittest
from test.support import (
- _4G, TESTFN, import_module, bigmemtest, run_unittest, unlink
+ _4G, TESTFN, import_module, bigmemtest, unlink
)
lzma = import_module("lzma")
)
-def test_main():
- run_unittest(
- CompressorDecompressorTestCase,
- CompressDecompressFunctionTestCase,
- FileTestCase,
- OpenTestCase,
- MiscellaneousTestCase,
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
support.check__all__(self, mailbox, blacklist=blacklist)
-def test_main():
- tests = (TestMailboxSuperclass, TestMaildir, TestMbox, TestMMDF, TestMH,
- TestBabyl, TestMessage, TestMaildirMessage, TestMboxMessage,
- TestMHMessage, TestBabylMessage, TestMMDFMessage,
- TestMessageConversion, TestProxyFile, TestPartialFile,
- MaildirTestCase, TestFakeMailBox, MiscTestCase)
- support.run_unittest(*tests)
+def tearDownModule():
support.reap_children()
if __name__ == '__main__':
- test_main()
+ unittest.main()
reset = b'~}'
expected_reset = expected + reset
-def test_main():
- support.run_unittest(__name__)
if __name__ == "__main__":
- test_main()
+ unittest.main()
support.check__all__(self, optparse, blacklist=blacklist)
-def test_main():
- support.run_unittest(__name__)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
mixer.close()
self.assertRaises(ValueError, mixer.fileno)
-def test_main():
+def setUpModule():
try:
dsp = ossaudiodev.open('w')
except (ossaudiodev.error, OSError) as msg:
raise unittest.SkipTest(msg)
raise
dsp.close()
- support.run_unittest(__name__)
if __name__ == "__main__":
- test_main()
+ unittest.main()
import string
import unittest
import shutil
-from test.support import TESTFN, run_unittest, unlink, reap_children
+from test.support import TESTFN, unlink, reap_children
if os.name != 'posix':
raise unittest.SkipTest('pipes module only works on posix')
self.assertNotEqual(id(t.steps), id(u.steps))
self.assertEqual(t.debugging, u.debugging)
-def test_main():
- run_unittest(SimplePipeTests)
+
+def tearDownModule():
reap_children()
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
from pathlib import Path
-from test.support import run_unittest, unload, check_warnings, CleanImport
+from test.support import unload, check_warnings, CleanImport
import unittest
import sys
import importlib
self.assertEqual(len(w.warnings), 0)
-def test_main():
- run_unittest(PkgutilTests, PkgutilPEP302Tests, ExtendPathTests,
- NestedNamespacePackageTest, ImportlibMigrationTests)
+def tearDownModule():
# this is necessary if test is run repeated (like when finding leaks)
import zipimport
import importlib
if __name__ == '__main__':
- test_main()
+ unittest.main()
import threading
import time
import unittest
-from test.support import TESTFN, run_unittest, reap_threads, cpython_only
+from test.support import TESTFN, reap_threads, cpython_only
try:
select.poll
os.close(w)
-def test_main():
- run_unittest(PollTests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
import errno
import threading
+import unittest
from unittest import TestCase, skipUnless
from test import support as test_support
from test.support import hashlib_helper
poplib.POP3(HOST, self.port, timeout=0)
-def test_main():
- tests = [TestPOP3Class, TestTimeouts,
- TestPOP3_SSLClass, TestPOP3_TLSClass]
+def setUpModule():
thread_info = test_support.threading_setup()
- try:
- test_support.run_unittest(*tests)
- finally:
- test_support.threading_cleanup(*thread_info)
+ unittest.addModuleCleanup(test_support.threading_cleanup, *thread_info)
if __name__ == '__main__':
- test_main()
+ unittest.main()
os.utime("path", dir_fd=0)
-def test_main():
- try:
- support.run_unittest(
- PosixTester,
- PosixGroupsTester,
- TestPosixSpawn,
- TestPosixSpawnP,
- TestPosixWeaklinking
- )
- finally:
- support.reap_children()
+def tearDownModule():
+ support.reap_children()
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
import os
from difflib import unified_diff
from io import StringIO
-from test.support import TESTFN, run_unittest, unlink, temp_dir, change_cwd
+from test.support import TESTFN, unlink, temp_dir, change_cwd
from contextlib import contextmanager
import profile
finally:
sys.stdout = stdout
-def test_main():
- run_unittest(ProfileTest)
def main():
if '-r' not in sys.argv:
- test_main()
+ unittest.main()
else:
regenerate_expected_output(__file__, ProfileTest)
self.assertIsNone(self._get_revised_path(trailing_argv0dir))
-@reap_threads
-def test_main():
- try:
- test.support.run_unittest(PydocDocTest,
- PydocImportTest,
- TestDescriptions,
- PydocServerTest,
- PydocUrlHandlerTest,
- TestHelper,
- PydocWithMetaClasses,
- TestInternalUtilities,
- )
- finally:
- reap_children()
+def setUpModule():
+ thread_info = test.support.threading_setup()
+ unittest.addModuleCleanup(test.support.threading_cleanup, *thread_info)
+ unittest.addModuleCleanup(reap_children)
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
limits)
-def test_main(verbose=None):
- support.run_unittest(ResourceTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
from urllib.error import URLError
import urllib.request
from test import support
-from test.support import findfile, run_unittest, FakePath, TESTFN
+from test.support import findfile, FakePath, TESTFN
TEST_XMLFILE = findfile("test.xml", subdir="xmltestdata")
TEST_XMLFILE_OUT = findfile("test.xml.out", subdir="xmltestdata")
self.assertEqual(attrs.getQNameByName((ns_uri, "attr")), "ns:attr")
-def test_main():
- run_unittest(MakeParserTest,
- ParseTest,
- SaxutilsTest,
- PrepareInputSourceTest,
- StringXmlgenTest,
- BytesXmlgenTest,
- WriterXmlgenTest,
- StreamWriterXmlgenTest,
- StreamReaderWriterXmlgenTest,
- ExpatReaderTest,
- ErrorReportingTest,
- XmlReaderTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
return match
-class BaseSelectorTestCase(unittest.TestCase):
+class BaseSelectorTestCase:
def make_socketpair(self):
rd, wr = socketpair()
self.assertEqual(NUM_FDS // 2, len(fds))
-class DefaultSelectorTestCase(BaseSelectorTestCase):
+class DefaultSelectorTestCase(BaseSelectorTestCase, unittest.TestCase):
SELECTOR = selectors.DefaultSelector
-class SelectSelectorTestCase(BaseSelectorTestCase):
+class SelectSelectorTestCase(BaseSelectorTestCase, unittest.TestCase):
SELECTOR = selectors.SelectSelector
@unittest.skipUnless(hasattr(selectors, 'PollSelector'),
"Test needs selectors.PollSelector")
-class PollSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn):
+class PollSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn,
+ unittest.TestCase):
SELECTOR = getattr(selectors, 'PollSelector', None)
@unittest.skipUnless(hasattr(selectors, 'EpollSelector'),
"Test needs selectors.EpollSelector")
-class EpollSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn):
+class EpollSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn,
+ unittest.TestCase):
SELECTOR = getattr(selectors, 'EpollSelector', None)
@unittest.skipUnless(hasattr(selectors, 'KqueueSelector'),
"Test needs selectors.KqueueSelector)")
-class KqueueSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn):
+class KqueueSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn,
+ unittest.TestCase):
SELECTOR = getattr(selectors, 'KqueueSelector', None)
@unittest.skipUnless(hasattr(selectors, 'DevpollSelector'),
"Test needs selectors.DevpollSelector")
-class DevpollSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn):
+class DevpollSelectorTestCase(BaseSelectorTestCase, ScalableSelectorMixIn,
+ unittest.TestCase):
SELECTOR = getattr(selectors, 'DevpollSelector', None)
-
-def test_main():
- tests = [DefaultSelectorTestCase, SelectSelectorTestCase,
- PollSelectorTestCase, EpollSelectorTestCase,
- KqueueSelectorTestCase, DevpollSelectorTestCase]
- support.run_unittest(*tests)
+def tearDownModule():
support.reap_children()
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.ssl_io_loop(sock, incoming, outgoing, sslobj.unwrap)
+@support.requires_resource('network')
class NetworkedTests(unittest.TestCase):
def test_timeout_connect_ex(self):
s.connect((HOST, server.port))
-def test_main(verbose=False):
+def setUpModule():
if support.verbose:
plats = {
'Mac': platform.mac_ver,
if not os.path.exists(filename):
raise support.TestFailed("Can't read certificate file %r" % filename)
- tests = [
- ContextTests, BasicSocketTests, SSLErrorTests, MemoryBIOTests,
- SSLObjectTests, SimpleBackgroundTests, ThreadedTests,
- TestPostHandshakeAuth, TestSSLDebug
- ]
-
- if support.is_resource_enabled('network'):
- tests.append(NetworkedTests)
-
thread_info = support.threading_setup()
- try:
- support.run_unittest(*tests)
- finally:
- support.threading_cleanup(*thread_info)
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
)
-def test_main():
- tests = [TestSupport]
- support.run_unittest(*tests)
-
if __name__ == '__main__':
- test_main()
+ unittest.main()
print('patchlevel =', tcl.call('info', 'patchlevel'))
-def test_main():
- support.run_unittest(TclTest, TkinterTest, BigmemTclTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
signal.signal(signal.SIGUSR1, old_handler)
-def test_main():
+def setUpModule():
global signal_blackboard
signal_blackboard = { signal.SIGUSR1 : {'tripped': 0, 'tripped_by': 0 },
signal.SIGALRM : {'tripped': 0, 'tripped_by': 0 } }
oldsigs = registerSignals(handle_signals, handle_signals, handle_signals)
- try:
- support.run_unittest(ThreadSignals)
- finally:
- registerSignals(*oldsigs)
+ unittest.addModuleCleanup(registerSignals, *oldsigs)
+
if __name__ == '__main__':
- test_main()
+ unittest.main()
self._sock_operation(1, 1.5, 'recvfrom', 1024)
-def test_main():
+def setUpModule():
support.requires('network')
- support.run_unittest(
- CreationTestCase,
- TCPTimeoutTestCase,
- UDPTimeoutTestCase,
- )
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.untrack()
-def test_main():
- support.run_unittest(
- TestTraceback,
- TestTracemallocEnabled,
- TestSnapshot,
- TestFilters,
- TestCommandLine,
- TestCAPI,
- )
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
import unicodedata
import unittest
-from test.support import (run_unittest, rmtree, change_cwd,
+from test.support import (rmtree, change_cwd,
TESTFN_ENCODING, TESTFN_UNICODE, TESTFN_UNENCODABLE, create_empty_file)
if not os.path.supports_unicode_filenames:
self._do_directory(TESTFN_UNENCODABLE+ext,
TESTFN_UNENCODABLE+ext)
-def test_main():
- run_unittest(__name__)
if __name__ == "__main__":
- test_main()
+ unittest.main()
normal_form = 'NFKD'
-def test_main():
- support.run_unittest(
- UnicodeFileTests,
- UnicodeNFCFileTests,
- UnicodeNFDFileTests,
- UnicodeNFKCFileTests,
- UnicodeNFKDFileTests,
- )
-
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
from test import support
-def test_main():
- # used by regrtest
- support.run_unittest(unittest.test.suite())
- support.reap_children()
-
def load_tests(*_):
# used by unittest
return unittest.test.suite()
+
+def tearDownModule():
+ support.reap_children()
+
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
self.assertEqual(index + 1, len(lines))
-threads_key = None
-
def setUpModule():
- # Store the threading_setup in a key and ensure that it is cleaned up
- # in the tearDown
- global threads_key
- threads_key = support.threading_setup()
-
-def tearDownModule():
- if threads_key:
- support.threading_cleanup(*threads_key)
+ thread_info = support.threading_setup()
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
+
if __name__ == "__main__":
unittest.main()
with self.assertRaises(FileNotFoundError) as ctx:
QueryValue(HKEY_CLASSES_ROOT, 'some_value_that_does_not_exist')
-def test_main():
- support.run_unittest(LocalWinregTests, RemoteWinregTests,
- Win64WinregTests)
if __name__ == "__main__":
if not REMOTE_NAME:
print("Remote registry calls can be tested using",
"'test_winreg.py --remote \\\\machine_name'")
- test_main()
+ unittest.main()
self.assertTrue(server.use_builtin_types)
-@support.reap_threads
-def test_main():
- support.run_unittest(XMLRPCTestCase, HelperTestCase, DateTimeTestCase,
- BinaryTestCase, FaultTestCase, UseBuiltinTypesTestCase,
- SimpleServerTestCase, SimpleServerEncodingTestCase,
- KeepaliveServerTestCase1, KeepaliveServerTestCase2,
- GzipServerTestCase, GzipUtilTestCase, HeadersServerTestCase,
- MultiPathServerTestCase, ServerProxyTestCase, FailingServerTestCase,
- CGIHandlerTestCase, SimpleXMLRPCDispatcherTestCase)
+def setUpModule():
+ thread_info = support.threading_setup()
+ unittest.addModuleCleanup(support.threading_cleanup, *thread_info)
if __name__ == "__main__":
- test_main()
+ unittest.main()
import xmlrpc.client as xmlrpclib
+support.requires("network")
+
+
@unittest.skip('XXX: buildbot.python.org/all/xmlrpc/ is gone')
class PythonBuildersTest(unittest.TestCase):
self.assertTrue([x for x in builders if "3.x" in x], builders)
-def test_main():
- support.requires("network")
- support.run_unittest(PythonBuildersTest)
-
if __name__ == "__main__":
- test_main()
+ unittest.main()
zipimport._zip_directory_cache.clear()
-def test_main():
- try:
- support.run_unittest(
- UncompressedZipImportTestCase,
- CompressedZipImportTestCase,
- BadFileZipImportTestCase,
- )
- finally:
- support.unlink(TESTMOD)
+def tearDownModule():
+ support.unlink(TESTMOD)
+
if __name__ == "__main__":
- test_main()
+ unittest.main()
projects / thirdparty / Python / cpython.git / commitdiff
