From 00bb43c97dae83d18ece8ee5d1452d9a7e9c2816 Mon Sep 17 00:00:00 2001 From: Serhiy Storchaka Date: Mon, 20 Sep 2021 10:26:02 +0300 Subject: [PATCH] bpo-45229: Use doctest.DocTestSuite instead of run_doctest Alo use load_tests() for adding tests. --- Lib/test/test_cmd.py | 10 +++++----- Lib/test/test_code.py | 16 +++++++--------- Lib/test/test_collections.py | 17 ++++------------- Lib/test/test_deque.py | 30 +++++------------------------- Lib/test/test_descrtut.py | 24 +++++++++--------------- Lib/test/test_extcall.py | 11 +++++++---- Lib/test/test_generators.py | 16 ++++++---------- Lib/test/test_genexps.py | 27 ++++++++++----------------- Lib/test/test_http_cookies.py | 12 +++++++----- Lib/test/test_itertools.py | 27 ++++++--------------------- Lib/test/test_listcomps.py | 25 +++++++++---------------- Lib/test/test_metaclass.py | 14 +++++++++----- Lib/test/test_setcomps.py | 25 +++++++++---------------- Lib/test/test_syntax.py | 11 ++++++----- Lib/test/test_unpack.py | 14 +++++++++----- Lib/test/test_unpack_ex.py | 14 +++++++++----- Lib/test/test_weakref.py | 17 +++++------------ 17 files changed, 122 insertions(+), 188 deletions(-) diff --git a/Lib/test/test_cmd.py b/Lib/test/test_cmd.py index 96e0c30da328cf..5e8b17c6e871a1 100644 --- a/Lib/test/test_cmd.py +++ b/Lib/test/test_cmd.py @@ -6,6 +6,7 @@ import cmd import sys +import doctest import unittest import io from test import support @@ -219,10 +220,9 @@ def test_input_reset_at_EOF(self): "(Cmd) *** Unknown syntax: EOF\n")) -def test_main(verbose=None): - from test import test_cmd - support.run_doctest(test_cmd, verbose) - support.run_unittest(TestAlternateInput) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests def test_coverage(coverdir): trace = support.import_module('trace') @@ -239,4 +239,4 @@ def test_coverage(coverdir): elif "-i" in sys.argv: samplecmdclass().cmdloop() else: - test_main() + unittest.main() diff --git a/Lib/test/test_code.py b/Lib/test/test_code.py index 64fd10da1ef214..0d46258d0c3715 100644 --- a/Lib/test/test_code.py +++ b/Lib/test/test_code.py @@ -128,6 +128,7 @@ import inspect import sys import threading +import doctest import unittest import textwrap import weakref @@ -136,7 +137,7 @@ import ctypes except ImportError: ctypes = None -from test.support import (run_doctest, run_unittest, cpython_only, +from test.support import (cpython_only, check_impl_detail, requires_debug_ranges, gc_collect) from test.support.script_helper import assert_python_ok @@ -609,13 +610,10 @@ def run(self): self.assertEqual(LAST_FREED, 500) -def test_main(verbose=None): - from test import test_code - run_doctest(test_code, verbose) - tests = [CodeTest, CodeConstsTest, CodeWeakRefTest] - if check_impl_detail(cpython=True) and ctypes is not None: - tests.append(CoExtra) - run_unittest(*tests) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main() + unittest.main() diff --git a/Lib/test/test_collections.py b/Lib/test/test_collections.py index 1f659d7d604e31..b9be4c03142b6d 100644 --- a/Lib/test/test_collections.py +++ b/Lib/test/test_collections.py @@ -2351,19 +2351,10 @@ def test_gt(self): self.assertFalse(Counter(a=2, b=1, c=0) > Counter('aab')) -################################################################################ -### Run tests -################################################################################ - -def test_main(verbose=None): - NamedTupleDocs = doctest.DocTestSuite(module=collections) - test_classes = [TestNamedTuple, NamedTupleDocs, TestOneTrickPonyABCs, - TestCollectionABCs, TestCounter, TestChainMap, - TestUserObjects, - ] - support.run_unittest(*test_classes) - support.run_doctest(collections, verbose) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite(collections)) + return tests if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_deque.py b/Lib/test/test_deque.py index 20cfc88b160318..0be3feca01049e 100644 --- a/Lib/test/test_deque.py +++ b/Lib/test/test_deque.py @@ -1,4 +1,5 @@ from collections import deque +import doctest import unittest from test import support, seq_tests import gc @@ -1033,31 +1034,10 @@ def test_free_after_iterating(self): __test__ = {'libreftest' : libreftest} -def test_main(verbose=None): - import sys - test_classes = ( - TestBasic, - TestVariousIteratorArgs, - TestSubclass, - TestSubclassWithKwargs, - TestSequence, - ) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests - support.run_unittest(*test_classes) - - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in range(len(counts)): - support.run_unittest(*test_classes) - gc.collect() - counts[i] = sys.gettotalrefcount() - print(counts) - - # doctests - from test import test_deque - support.run_doctest(test_deque, verbose) if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_descrtut.py b/Lib/test/test_descrtut.py index 8e25f58d7aa20e..2af683e707ca89 100644 --- a/Lib/test/test_descrtut.py +++ b/Lib/test/test_descrtut.py @@ -10,6 +10,9 @@ from test.support import sortdict import pprint +import doctest +import unittest + class defaultdict(dict): def __init__(self, default=None): @@ -469,19 +472,10 @@ def m(self): "tut7": test_7, "tut8": test_8} -# Magic test name that regrtest.py invokes *after* importing this module. -# This worms around a bootstrap problem. -# Note that doctest and regrtest both look in sys.argv for a "-v" argument, -# so this works as expected in both ways of running regrtest. -def test_main(verbose=None): - # Obscure: import this module as test.test_descrtut instead of as - # plain test_descrtut because the name of this module works its way - # into the doctest examples, and unless the full test.test_descrtut - # business is used the name can change depending on how the test is - # invoked. - from test import support, test_descrtut - support.run_doctest(test_descrtut, verbose) - -# This part isn't needed for regrtest, but for running the test directly. +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + + if __name__ == "__main__": - test_main(1) + unittest.main() diff --git a/Lib/test/test_extcall.py b/Lib/test/test_extcall.py index 4205ca82222f27..13265ea0d8ce85 100644 --- a/Lib/test/test_extcall.py +++ b/Lib/test/test_extcall.py @@ -520,11 +520,14 @@ """ -import sys +import doctest +import unittest from test import support -def test_main(): - support.run_doctest(sys.modules[__name__], True) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == '__main__': - test_main() + unittest.main() diff --git a/Lib/test/test_generators.py b/Lib/test/test_generators.py index d14c757c7b6e43..433204b09fee65 100644 --- a/Lib/test/test_generators.py +++ b/Lib/test/test_generators.py @@ -2,6 +2,7 @@ import gc import pickle import sys +import doctest import unittest import weakref import inspect @@ -2371,15 +2372,10 @@ def printsolution(self, x): "refleaks": refleaks_tests, } -# Magic test name that regrtest.py invokes *after* importing this module. -# This worms around a bootstrap problem. -# Note that doctest and regrtest both look in sys.argv for a "-v" argument, -# so this works as expected in both ways of running regrtest. -def test_main(verbose=None): - from test import support, test_generators - support.run_unittest(__name__) - support.run_doctest(test_generators, verbose) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + -# This part isn't needed for regrtest, but for running the test directly. if __name__ == "__main__": - test_main(1) + unittest.main() diff --git a/Lib/test/test_genexps.py b/Lib/test/test_genexps.py index 70fe2bba3a6982..4f2d3cdcc7943e 100644 --- a/Lib/test/test_genexps.py +++ b/Lib/test/test_genexps.py @@ -1,3 +1,8 @@ +import sys +import doctest +import unittest + + doctests = """ Test simple loop with conditional @@ -274,28 +279,16 @@ """ -import sys - # Trace function can throw off the tuple reuse test. if hasattr(sys, 'gettrace') and sys.gettrace(): __test__ = {} else: __test__ = {'doctests' : doctests} -def test_main(verbose=None): - from test import support - from test import test_genexps - support.run_doctest(test_genexps, verbose) - - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in range(len(counts)): - support.run_doctest(test_genexps, verbose) - gc.collect() - counts[i] = sys.gettotalrefcount() - print(counts) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_http_cookies.py b/Lib/test/test_http_cookies.py index 6072c7e15e92be..925c8697f60de6 100644 --- a/Lib/test/test_http_cookies.py +++ b/Lib/test/test_http_cookies.py @@ -1,8 +1,8 @@ # Simple test suite for http/cookies.py import copy -from test.support import run_unittest, run_doctest import unittest +import doctest from http import cookies import pickle @@ -479,9 +479,11 @@ def test_repr(self): r'Set-Cookie: key=coded_val; ' r'expires=\w+, \d+ \w+ \d+ \d+:\d+:\d+ \w+') -def test_main(): - run_unittest(CookieTests, MorselTests) - run_doctest(cookies) + +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite(cookies)) + return tests + if __name__ == '__main__': - test_main() + unittest.main() diff --git a/Lib/test/test_itertools.py b/Lib/test/test_itertools.py index db6a98351bbd9b..be18497967c70b 100644 --- a/Lib/test/test_itertools.py +++ b/Lib/test/test_itertools.py @@ -1,3 +1,4 @@ +import doctest import unittest from test import support from itertools import * @@ -2689,26 +2690,10 @@ def test_permutations_sizeof(self): __test__ = {'libreftest' : libreftest} -def test_main(verbose=None): - test_classes = (TestBasicOps, TestVariousIteratorArgs, TestGC, - RegressionTests, LengthTransparency, - SubclassWithKwargsTest, TestExamples, - TestPurePythonRoughEquivalents, - SizeofTest) - support.run_unittest(*test_classes) - - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in range(len(counts)): - support.run_unittest(*test_classes) - gc.collect() - counts[i] = sys.gettotalrefcount() - print(counts) - - # doctest the examples in the library reference - support.run_doctest(sys.modules[__name__], verbose) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_listcomps.py b/Lib/test/test_listcomps.py index 62b3319ad936d7..91bf2547edc4ae 100644 --- a/Lib/test/test_listcomps.py +++ b/Lib/test/test_listcomps.py @@ -1,3 +1,7 @@ +import doctest +import unittest + + doctests = """ ########### Tests borrowed from or inspired by test_genexps.py ############ @@ -144,21 +148,10 @@ __test__ = {'doctests' : doctests} -def test_main(verbose=None): - import sys - from test import support - from test import test_listcomps - support.run_doctest(test_listcomps, verbose) - - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in range(len(counts)): - support.run_doctest(test_listcomps, verbose) - gc.collect() - counts[i] = sys.gettotalrefcount() - print(counts) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_metaclass.py b/Lib/test/test_metaclass.py index 6edd899b0d2132..36e8ab4cda3dad 100644 --- a/Lib/test/test_metaclass.py +++ b/Lib/test/test_metaclass.py @@ -1,3 +1,7 @@ +import doctest +import unittest + + doctests = """ Basic class construction. @@ -256,10 +260,10 @@ else: __test__ = {'doctests' : doctests} -def test_main(verbose=False): - from test import support - from test import test_metaclass - support.run_doctest(test_metaclass, verbose) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_setcomps.py b/Lib/test/test_setcomps.py index ecc4fffec0d849..976fa885bd8ef9 100644 --- a/Lib/test/test_setcomps.py +++ b/Lib/test/test_setcomps.py @@ -1,3 +1,7 @@ +import doctest +import unittest + + doctests = """ ########### Tests mostly copied from test_listcomps.py ############ @@ -147,21 +151,10 @@ __test__ = {'doctests' : doctests} -def test_main(verbose=None): - import sys - from test import support - from test import test_setcomps - support.run_doctest(test_setcomps, verbose) - - # verify reference counting - if verbose and hasattr(sys, "gettotalrefcount"): - import gc - counts = [None] * 5 - for i in range(len(counts)): - support.run_doctest(test_setcomps, verbose) - gc.collect() - counts[i] = sys.gettotalrefcount() - print(counts) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_syntax.py b/Lib/test/test_syntax.py index be8be898d01962..aa86d0cd1d4801 100644 --- a/Lib/test/test_syntax.py +++ b/Lib/test/test_syntax.py @@ -1266,6 +1266,7 @@ """ import re +import doctest import unittest from test import support @@ -1554,10 +1555,10 @@ def test_syntax_error_on_deeply_nested_blocks(self): self._check_error(source, "too many statically nested blocks") -def test_main(): - support.run_unittest(SyntaxTestCase) - from test import test_syntax - support.run_doctest(test_syntax, verbosity=True) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main() + unittest.main() diff --git a/Lib/test/test_unpack.py b/Lib/test/test_unpack.py index 1c0c523d685836..472c8343eb2433 100644 --- a/Lib/test/test_unpack.py +++ b/Lib/test/test_unpack.py @@ -1,3 +1,7 @@ +import doctest +import unittest + + doctests = """ Unpack tuple @@ -142,10 +146,10 @@ __test__ = {'doctests' : doctests} -def test_main(verbose=False): - from test import support - from test import test_unpack - support.run_doctest(test_unpack, verbose) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_unpack_ex.py b/Lib/test/test_unpack_ex.py index bd79421e6e2b37..c201d08f61b8cd 100644 --- a/Lib/test/test_unpack_ex.py +++ b/Lib/test/test_unpack_ex.py @@ -1,5 +1,9 @@ # Tests for extended unpacking, starred expressions. +import doctest +import unittest + + doctests = """ Unpack tuple @@ -392,10 +396,10 @@ __test__ = {'doctests' : doctests} -def test_main(verbose=False): - from test import support - from test import test_unpack_ex - support.run_doctest(test_unpack_ex, verbose) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests + if __name__ == "__main__": - test_main(verbose=True) + unittest.main() diff --git a/Lib/test/test_weakref.py b/Lib/test/test_weakref.py index 5a3e59c3e9ef15..3bdc86d6923e02 100644 --- a/Lib/test/test_weakref.py +++ b/Lib/test/test_weakref.py @@ -1,5 +1,6 @@ import gc import sys +import doctest import unittest import collections import weakref @@ -2233,18 +2234,10 @@ def test_atexit(self): __test__ = {'libreftest' : libreftest} -def test_main(): - support.run_unittest( - ReferencesTestCase, - WeakMethodTestCase, - MappingTestCase, - WeakValueDictionaryTestCase, - WeakKeyDictionaryTestCase, - SubclassableWeakrefTestCase, - FinalizeTestCase, - ) - support.run_doctest(sys.modules[__name__]) +def load_tests(loader, tests, pattern): + tests.addTest(doctest.DocTestSuite()) + return tests if __name__ == "__main__": - test_main() + unittest.main()