Issue #25220: Move most regrtest.py code to libregrtest

1 files changed, 48 insertions, 47 deletions

diff --git a/Lib/test/test_regrtest.py b/Lib/test/test_regrtest.py
index cf4b84f..f744127 100644
--- a/Lib/test/test_regrtest.py
+++ b/Lib/test/test_regrtest.py
@@ -7,7 +7,8 @@ import faulthandler
 import getopt
 import os.path
 import unittest
-from test import regrtest, support, libregrtest
+from test import libregrtest
+from test import support
 
 class ParseArgsTestCase(unittest.TestCase):
 
@@ -15,7 +16,7 @@ class ParseArgsTestCase(unittest.TestCase):
 
     def checkError(self, args, msg):
         with support.captured_stderr() as err, self.assertRaises(SystemExit):
-            regrtest._parse_args(args)
+            libregrtest._parse_args(args)
         self.assertIn(msg, err.getvalue())
 
     def test_help(self):
@@ -23,82 +24,82 @@ class ParseArgsTestCase(unittest.TestCase):
             with self.subTest(opt=opt):
                 with support.captured_stdout() as out, \
                      self.assertRaises(SystemExit):
-                    regrtest._parse_args([opt])
+                    libregrtest._parse_args([opt])
                 self.assertIn('Run Python regression tests.', out.getvalue())
 
     @unittest.skipUnless(hasattr(faulthandler, 'dump_traceback_later'),
                          "faulthandler.dump_traceback_later() required")
     def test_timeout(self):
-        ns = regrtest._parse_args(['--timeout', '4.2'])
+        ns = libregrtest._parse_args(['--timeout', '4.2'])
         self.assertEqual(ns.timeout, 4.2)
         self.checkError(['--timeout'], 'expected one argument')
         self.checkError(['--timeout', 'foo'], 'invalid float value')
 
     def test_wait(self):
-        ns = regrtest._parse_args(['--wait'])
+        ns = libregrtest._parse_args(['--wait'])
         self.assertTrue(ns.wait)
 
     def test_slaveargs(self):
-        ns = regrtest._parse_args(['--slaveargs', '[[], {}]'])
+        ns = libregrtest._parse_args(['--slaveargs', '[[], {}]'])
         self.assertEqual(ns.slaveargs, '[[], {}]')
         self.checkError(['--slaveargs'], 'expected one argument')
 
     def test_start(self):
         for opt in '-S', '--start':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, 'foo'])
+                ns = libregrtest._parse_args([opt, 'foo'])
                 self.assertEqual(ns.start, 'foo')
                 self.checkError([opt], 'expected one argument')
 
     def test_verbose(self):
-        ns = regrtest._parse_args(['-v'])
+        ns = libregrtest._parse_args(['-v'])
         self.assertEqual(ns.verbose, 1)
-        ns = regrtest._parse_args(['-vvv'])
+        ns = libregrtest._parse_args(['-vvv'])
         self.assertEqual(ns.verbose, 3)
-        ns = regrtest._parse_args(['--verbose'])
+        ns = libregrtest._parse_args(['--verbose'])
         self.assertEqual(ns.verbose, 1)
-        ns = regrtest._parse_args(['--verbose'] * 3)
+        ns = libregrtest._parse_args(['--verbose'] * 3)
         self.assertEqual(ns.verbose, 3)
-        ns = regrtest._parse_args([])
+        ns = libregrtest._parse_args([])
         self.assertEqual(ns.verbose, 0)
 
     def test_verbose2(self):
         for opt in '-w', '--verbose2':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.verbose2)
 
     def test_verbose3(self):
         for opt in '-W', '--verbose3':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.verbose3)
 
     def test_quiet(self):
         for opt in '-q', '--quiet':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.quiet)
                 self.assertEqual(ns.verbose, 0)
 
     def test_slow(self):
         for opt in '-o', '--slow':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.print_slow)
 
     def test_header(self):
-        ns = regrtest._parse_args(['--header'])
+        ns = libregrtest._parse_args(['--header'])
         self.assertTrue(ns.header)
 
     def test_randomize(self):
         for opt in '-r', '--randomize':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.randomize)
 
     def test_randseed(self):
-        ns = regrtest._parse_args(['--randseed', '12345'])
+        ns = libregrtest._parse_args(['--randseed', '12345'])
         self.assertEqual(ns.random_seed, 12345)
         self.assertTrue(ns.randomize)
         self.checkError(['--randseed'], 'expected one argument')
@@ -107,7 +108,7 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_fromfile(self):
         for opt in '-f', '--fromfile':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, 'foo'])
+                ns = libregrtest._parse_args([opt, 'foo'])
                 self.assertEqual(ns.fromfile, 'foo')
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo', '-s'], "don't go together")
@@ -115,42 +116,42 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_exclude(self):
         for opt in '-x', '--exclude':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.exclude)
 
     def test_single(self):
         for opt in '-s', '--single':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.single)
                 self.checkError([opt, '-f', 'foo'], "don't go together")
 
     def test_match(self):
         for opt in '-m', '--match':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, 'pattern'])
+                ns = libregrtest._parse_args([opt, 'pattern'])
                 self.assertEqual(ns.match_tests, 'pattern')
                 self.checkError([opt], 'expected one argument')
 
     def test_failfast(self):
         for opt in '-G', '--failfast':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, '-v'])
+                ns = libregrtest._parse_args([opt, '-v'])
                 self.assertTrue(ns.failfast)
-                ns = regrtest._parse_args([opt, '-W'])
+                ns = libregrtest._parse_args([opt, '-W'])
                 self.assertTrue(ns.failfast)
                 self.checkError([opt], '-G/--failfast needs either -v or -W')
 
     def test_use(self):
         for opt in '-u', '--use':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, 'gui,network'])
+                ns = libregrtest._parse_args([opt, 'gui,network'])
                 self.assertEqual(ns.use_resources, ['gui', 'network'])
-                ns = regrtest._parse_args([opt, 'gui,none,network'])
+                ns = libregrtest._parse_args([opt, 'gui,none,network'])
                 self.assertEqual(ns.use_resources, ['network'])
                 expected = list(libregrtest.RESOURCE_NAMES)
                 expected.remove('gui')
-                ns = regrtest._parse_args([opt, 'all,-gui'])
+                ns = libregrtest._parse_args([opt, 'all,-gui'])
                 self.assertEqual(ns.use_resources, expected)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid resource')
@@ -158,31 +159,31 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_memlimit(self):
         for opt in '-M', '--memlimit':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, '4G'])
+                ns = libregrtest._parse_args([opt, '4G'])
                 self.assertEqual(ns.memlimit, '4G')
                 self.checkError([opt], 'expected one argument')
 
     def test_testdir(self):
-        ns = regrtest._parse_args(['--testdir', 'foo'])
+        ns = libregrtest._parse_args(['--testdir', 'foo'])
         self.assertEqual(ns.testdir, os.path.join(support.SAVEDCWD, 'foo'))
         self.checkError(['--testdir'], 'expected one argument')
 
     def test_runleaks(self):
         for opt in '-L', '--runleaks':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.runleaks)
 
     def test_huntrleaks(self):
         for opt in '-R', '--huntrleaks':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, ':'])
+                ns = libregrtest._parse_args([opt, ':'])
                 self.assertEqual(ns.huntrleaks, (5, 4, 'reflog.txt'))
-                ns = regrtest._parse_args([opt, '6:'])
+                ns = libregrtest._parse_args([opt, '6:'])
                 self.assertEqual(ns.huntrleaks, (6, 4, 'reflog.txt'))
-                ns = regrtest._parse_args([opt, ':3'])
+                ns = libregrtest._parse_args([opt, ':3'])
                 self.assertEqual(ns.huntrleaks, (5, 3, 'reflog.txt'))
-                ns = regrtest._parse_args([opt, '6:3:leaks.log'])
+                ns = libregrtest._parse_args([opt, '6:3:leaks.log'])
                 self.assertEqual(ns.huntrleaks, (6, 3, 'leaks.log'))
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, '6'],
@@ -193,7 +194,7 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_multiprocess(self):
         for opt in '-j', '--multiprocess':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, '2'])
+                ns = libregrtest._parse_args([opt, '2'])
                 self.assertEqual(ns.use_mp, 2)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid int value')
@@ -204,13 +205,13 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_coverage(self):
         for opt in '-T', '--coverage':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.trace)
 
     def test_coverdir(self):
         for opt in '-D', '--coverdir':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, 'foo'])
+                ns = libregrtest._parse_args([opt, 'foo'])
                 self.assertEqual(ns.coverdir,
                                  os.path.join(support.SAVEDCWD, 'foo'))
                 self.checkError([opt], 'expected one argument')
@@ -218,13 +219,13 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_nocoverdir(self):
         for opt in '-N', '--nocoverdir':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertIsNone(ns.coverdir)
 
     def test_threshold(self):
         for opt in '-t', '--threshold':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt, '1000'])
+                ns = libregrtest._parse_args([opt, '1000'])
                 self.assertEqual(ns.threshold, 1000)
                 self.checkError([opt], 'expected one argument')
                 self.checkError([opt, 'foo'], 'invalid int value')
@@ -232,13 +233,13 @@ class ParseArgsTestCase(unittest.TestCase):
     def test_nowindows(self):
         for opt in '-n', '--nowindows':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.nowindows)
 
     def test_forever(self):
         for opt in '-F', '--forever':
             with self.subTest(opt=opt):
-                ns = regrtest._parse_args([opt])
+                ns = libregrtest._parse_args([opt])
                 self.assertTrue(ns.forever)
 
 
@@ -246,26 +247,26 @@ class ParseArgsTestCase(unittest.TestCase):
         self.checkError(['--xxx'], 'usage:')
 
     def test_long_option__partial(self):
-        ns = regrtest._parse_args(['--qui'])
+        ns = libregrtest._parse_args(['--qui'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
 
     def test_two_options(self):
-        ns = regrtest._parse_args(['--quiet', '--exclude'])
+        ns = libregrtest._parse_args(['--quiet', '--exclude'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
         self.assertTrue(ns.exclude)
 
     def test_option_with_empty_string_value(self):
-        ns = regrtest._parse_args(['--start', ''])
+        ns = libregrtest._parse_args(['--start', ''])
         self.assertEqual(ns.start, '')
 
     def test_arg(self):
-        ns = regrtest._parse_args(['foo'])
+        ns = libregrtest._parse_args(['foo'])
         self.assertEqual(ns.args, ['foo'])
 
     def test_option_and_arg(self):
-        ns = regrtest._parse_args(['--quiet', 'foo'])
+        ns = libregrtest._parse_args(['--quiet', 'foo'])
         self.assertTrue(ns.quiet)
         self.assertEqual(ns.verbose, 0)
         self.assertEqual(ns.args, ['foo'])