removed /etc and /opt

opt/plesk/python/3/lib/python3.10/test/test_tools/__init__.py

@@ -1,45 +0,0 @@
-"""Support functions for testing scripts in the Tools directory."""
-import contextlib
-import importlib
-import os.path
-import unittest
-from test import support
-from test.support import import_helper
-
-
-if support.check_sanitizer(address=True, memory=True):
-    # bpo-46633: Skip the test because it is too slow when Python is built
-    # with ASAN/MSAN: between 5 and 20 minutes on GitHub Actions.
-    raise unittest.SkipTest("test too slow on ASAN/MSAN build")
-
-
-basepath = os.path.normpath(
-        os.path.dirname(                 # <src/install dir>
-            os.path.dirname(                # Lib
-                os.path.dirname(                # test
-                    os.path.dirname(__file__)))))    # test_tools
-
-toolsdir = os.path.join(basepath, 'Tools')
-scriptsdir = os.path.join(toolsdir, 'scripts')
-
-def skip_if_missing(tool=None):
-    if tool:
-        tooldir = os.path.join(toolsdir, tool)
-    else:
-        tool = 'scripts'
-        tooldir = scriptsdir
-    if not os.path.isdir(tooldir):
-        raise unittest.SkipTest(f'{tool} directory could not be found')
-
-@contextlib.contextmanager
-def imports_under_tool(name, *subdirs):
-    tooldir = os.path.join(toolsdir, name, *subdirs)
-    with import_helper.DirsOnSysPath(tooldir) as cm:
-        yield cm
-
-def import_tool(toolname):
-    with import_helper.DirsOnSysPath(scriptsdir):
-        return importlib.import_module(toolname)
-
-def load_tests(*args):
-    return support.load_package_tests(os.path.dirname(__file__), *args)

opt/plesk/python/3/lib/python3.10/test/test_tools/__main__.py

@@ -1,4 +0,0 @@
-from test.test_tools import load_tests
-import unittest
-
-unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_fixcid.py

@@ -1,93 +0,0 @@
-'''Test Tools/scripts/fixcid.py.'''
-
-from io import StringIO
-import os, os.path
-import runpy
-import sys
-from test import support
-from test.support import os_helper
-from test.test_tools import skip_if_missing, scriptsdir
-import unittest
-
-skip_if_missing()
-
-class Test(unittest.TestCase):
-    def test_parse_strings(self):
-        old1 = 'int xx = "xx\\"xx"[xx];\n'
-        old2 = "int xx = 'x\\'xx' + xx;\n"
-        output = self.run_script(old1 + old2)
-        new1 = 'int yy = "xx\\"xx"[yy];\n'
-        new2 = "int yy = 'x\\'xx' + yy;\n"
-        self.assertMultiLineEqual(output,
-            "1\n"
-            "< {old1}"
-            "> {new1}"
-            "{new1}"
-            "2\n"
-            "< {old2}"
-            "> {new2}"
-            "{new2}".format(old1=old1, old2=old2, new1=new1, new2=new2)
-        )
-
-    def test_alter_comments(self):
-        output = self.run_script(
-            substfile=
-                "xx yy\n"
-                "*aa bb\n",
-            args=("-c", "-",),
-            input=
-                "/* xx altered */\n"
-                "int xx;\n"
-                "/* aa unaltered */\n"
-                "int aa;\n",
-        )
-        self.assertMultiLineEqual(output,
-            "1\n"
-            "< /* xx altered */\n"
-            "> /* yy altered */\n"
-            "/* yy altered */\n"
-            "2\n"
-            "< int xx;\n"
-            "> int yy;\n"
-            "int yy;\n"
-            "/* aa unaltered */\n"
-            "4\n"
-            "< int aa;\n"
-            "> int bb;\n"
-            "int bb;\n"
-        )
-
-    def test_directory(self):
-        os.mkdir(os_helper.TESTFN)
-        self.addCleanup(os_helper.rmtree, os_helper.TESTFN)
-        c_filename = os.path.join(os_helper.TESTFN, "file.c")
-        with open(c_filename, "w") as file:
-            file.write("int xx;\n")
-        with open(os.path.join(os_helper.TESTFN, "file.py"), "w") as file:
-            file.write("xx = 'unaltered'\n")
-        script = os.path.join(scriptsdir, "fixcid.py")
-        output = self.run_script(args=(os_helper.TESTFN,))
-        self.assertMultiLineEqual(output,
-            "{}:\n"
-            "1\n"
-            '< int xx;\n'
-            '> int yy;\n'.format(c_filename)
-        )
-
-    def run_script(self, input="", *, args=("-",), substfile="xx yy\n"):
-        substfilename = os_helper.TESTFN + ".subst"
-        with open(substfilename, "w") as file:
-            file.write(substfile)
-        self.addCleanup(os_helper.unlink, substfilename)
-
-        argv = ["fixcid.py", "-s", substfilename] + list(args)
-        script = os.path.join(scriptsdir, "fixcid.py")
-        with support.swap_attr(sys, "argv", argv), \
-                support.swap_attr(sys, "stdin", StringIO(input)), \
-                support.captured_stdout() as output, \
-                support.captured_stderr():
-            try:
-                runpy.run_path(script, run_name="__main__")
-            except SystemExit as exit:
-                self.assertEqual(exit.code, 0)
-        return output.getvalue()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_gprof2html.py

@@ -1,35 +0,0 @@
-"""Tests for the gprof2html script in the Tools directory."""
-
-import os
-import sys
-import unittest
-from unittest import mock
-import tempfile
-
-from test.test_tools import skip_if_missing, import_tool
-
-skip_if_missing()
-
-class Gprof2htmlTests(unittest.TestCase):
-
-    def setUp(self):
-        self.gprof = import_tool('gprof2html')
-        oldargv = sys.argv
-        def fixup():
-            sys.argv = oldargv
-        self.addCleanup(fixup)
-        sys.argv = []
-
-    def test_gprof(self):
-        # Issue #14508: this used to fail with a NameError.
-        with mock.patch.object(self.gprof, 'webbrowser') as wmock, \
-                tempfile.TemporaryDirectory() as tmpdir:
-            fn = os.path.join(tmpdir, 'abc')
-            open(fn, 'w').close()
-            sys.argv = ['gprof2html', fn]
-            self.gprof.main()
-        self.assertTrue(wmock.open.called)
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_i18n.py

@@ -1,335 +0,0 @@
-"""Tests to cover the Tools/i18n package"""
-
-import os
-import sys
-import unittest
-from textwrap import dedent
-
-from test.support.script_helper import assert_python_ok
-from test.test_tools import skip_if_missing, toolsdir
-from test.support.os_helper import temp_cwd, temp_dir
-
-
-skip_if_missing()
-
-
-class Test_pygettext(unittest.TestCase):
-    """Tests for the pygettext.py tool"""
-
-    script = os.path.join(toolsdir,'i18n', 'pygettext.py')
-
-    def get_header(self, data):
-        """ utility: return the header of a .po file as a dictionary """
-        headers = {}
-        for line in data.split('\n'):
-            if not line or line.startswith(('#', 'msgid','msgstr')):
-                continue
-            line = line.strip('"')
-            key, val = line.split(':',1)
-            headers[key] = val.strip()
-        return headers
-
-    def get_msgids(self, data):
-        """ utility: return all msgids in .po file as a list of strings """
-        msgids = []
-        reading_msgid = False
-        cur_msgid = []
-        for line in data.split('\n'):
-            if reading_msgid:
-                if line.startswith('"'):
-                    cur_msgid.append(line.strip('"'))
-                else:
-                    msgids.append('\n'.join(cur_msgid))
-                    cur_msgid = []
-                    reading_msgid = False
-                    continue
-            if line.startswith('msgid '):
-                line = line[len('msgid '):]
-                cur_msgid.append(line.strip('"'))
-                reading_msgid = True
-        else:
-            if reading_msgid:
-                msgids.append('\n'.join(cur_msgid))
-
-        return msgids
-
-    def extract_docstrings_from_str(self, module_content):
-        """ utility: return all msgids extracted from module_content """
-        filename = 'test_docstrings.py'
-        with temp_cwd(None) as cwd:
-            with open(filename, 'w') as fp:
-                fp.write(module_content)
-            assert_python_ok(self.script, '-D', filename)
-            with open('messages.pot') as fp:
-                data = fp.read()
-        return self.get_msgids(data)
-
-    def test_header(self):
-        """Make sure the required fields are in the header, according to:
-           http://www.gnu.org/software/gettext/manual/gettext.html#Header-Entry
-        """
-        with temp_cwd(None) as cwd:
-            assert_python_ok(self.script)
-            with open('messages.pot') as fp:
-                data = fp.read()
-            header = self.get_header(data)
-
-            self.assertIn("Project-Id-Version", header)
-            self.assertIn("POT-Creation-Date", header)
-            self.assertIn("PO-Revision-Date", header)
-            self.assertIn("Last-Translator", header)
-            self.assertIn("Language-Team", header)
-            self.assertIn("MIME-Version", header)
-            self.assertIn("Content-Type", header)
-            self.assertIn("Content-Transfer-Encoding", header)
-            self.assertIn("Generated-By", header)
-
-            # not clear if these should be required in POT (template) files
-            #self.assertIn("Report-Msgid-Bugs-To", header)
-            #self.assertIn("Language", header)
-
-            #"Plural-Forms" is optional
-
-    @unittest.skipIf(sys.platform.startswith('aix'),
-                     'bpo-29972: broken test on AIX')
-    def test_POT_Creation_Date(self):
-        """ Match the date format from xgettext for POT-Creation-Date """
-        from datetime import datetime
-        with temp_cwd(None) as cwd:
-            assert_python_ok(self.script)
-            with open('messages.pot') as fp:
-                data = fp.read()
-            header = self.get_header(data)
-            creationDate = header['POT-Creation-Date']
-
-            # peel off the escaped newline at the end of string
-            if creationDate.endswith('\\n'):
-                creationDate = creationDate[:-len('\\n')]
-
-            # This will raise if the date format does not exactly match.
-            datetime.strptime(creationDate, '%Y-%m-%d %H:%M%z')
-
-    def test_funcdocstring(self):
-        for doc in ('"""doc"""', "r'''doc'''", "R'doc'", 'u"doc"'):
-            with self.subTest(doc):
-                msgids = self.extract_docstrings_from_str(dedent('''\
-                def foo(bar):
-                    %s
-                ''' % doc))
-                self.assertIn('doc', msgids)
-
-    def test_funcdocstring_bytes(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        def foo(bar):
-            b"""doc"""
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_funcdocstring_fstring(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        def foo(bar):
-            f"""doc"""
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_classdocstring(self):
-        for doc in ('"""doc"""', "r'''doc'''", "R'doc'", 'u"doc"'):
-            with self.subTest(doc):
-                msgids = self.extract_docstrings_from_str(dedent('''\
-                class C:
-                    %s
-                ''' % doc))
-                self.assertIn('doc', msgids)
-
-    def test_classdocstring_bytes(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        class C:
-            b"""doc"""
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_classdocstring_fstring(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        class C:
-            f"""doc"""
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_moduledocstring(self):
-        for doc in ('"""doc"""', "r'''doc'''", "R'doc'", 'u"doc"'):
-            with self.subTest(doc):
-                msgids = self.extract_docstrings_from_str(dedent('''\
-                %s
-                ''' % doc))
-                self.assertIn('doc', msgids)
-
-    def test_moduledocstring_bytes(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        b"""doc"""
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_moduledocstring_fstring(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"""doc"""
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_msgid(self):
-        msgids = self.extract_docstrings_from_str(
-                '''_("""doc""" r'str' u"ing")''')
-        self.assertIn('docstring', msgids)
-
-    def test_msgid_bytes(self):
-        msgids = self.extract_docstrings_from_str('_(b"""doc""")')
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_msgid_fstring(self):
-        msgids = self.extract_docstrings_from_str('_(f"""doc""")')
-        self.assertFalse([msgid for msgid in msgids if 'doc' in msgid])
-
-    def test_funcdocstring_annotated_args(self):
-        """ Test docstrings for functions with annotated args """
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        def foo(bar: str):
-            """doc"""
-        '''))
-        self.assertIn('doc', msgids)
-
-    def test_funcdocstring_annotated_return(self):
-        """ Test docstrings for functions with annotated return type """
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        def foo(bar) -> str:
-            """doc"""
-        '''))
-        self.assertIn('doc', msgids)
-
-    def test_funcdocstring_defvalue_args(self):
-        """ Test docstring for functions with default arg values """
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        def foo(bar=()):
-            """doc"""
-        '''))
-        self.assertIn('doc', msgids)
-
-    def test_funcdocstring_multiple_funcs(self):
-        """ Test docstring extraction for multiple functions combining
-        annotated args, annotated return types and default arg values
-        """
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        def foo1(bar: tuple=()) -> str:
-            """doc1"""
-
-        def foo2(bar: List[1:2]) -> (lambda x: x):
-            """doc2"""
-
-        def foo3(bar: 'func'=lambda x: x) -> {1: 2}:
-            """doc3"""
-        '''))
-        self.assertIn('doc1', msgids)
-        self.assertIn('doc2', msgids)
-        self.assertIn('doc3', msgids)
-
-    def test_classdocstring_early_colon(self):
-        """ Test docstring extraction for a class with colons occurring within
-        the parentheses.
-        """
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        class D(L[1:2], F({1: 2}), metaclass=M(lambda x: x)):
-            """doc"""
-        '''))
-        self.assertIn('doc', msgids)
-
-    def test_calls_in_fstrings(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_('foo bar')}"
-        '''))
-        self.assertIn('foo bar', msgids)
-
-    def test_calls_in_fstrings_raw(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        rf"{_('foo bar')}"
-        '''))
-        self.assertIn('foo bar', msgids)
-
-    def test_calls_in_fstrings_nested(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"""{f'{_("foo bar")}'}"""
-        '''))
-        self.assertIn('foo bar', msgids)
-
-    def test_calls_in_fstrings_attribute(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{obj._('foo bar')}"
-        '''))
-        self.assertIn('foo bar', msgids)
-
-    def test_calls_in_fstrings_with_call_on_call(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{type(str)('foo bar')}"
-        '''))
-        self.assertNotIn('foo bar', msgids)
-
-    def test_calls_in_fstrings_with_format(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_('foo {bar}').format(bar='baz')}"
-        '''))
-        self.assertIn('foo {bar}', msgids)
-
-    def test_calls_in_fstrings_with_wrong_input_1(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_(f'foo {bar}')}"
-        '''))
-        self.assertFalse([msgid for msgid in msgids if 'foo {bar}' in msgid])
-
-    def test_calls_in_fstrings_with_wrong_input_2(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_(1)}"
-        '''))
-        self.assertNotIn(1, msgids)
-
-    def test_calls_in_fstring_with_multiple_args(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_('foo', 'bar')}"
-        '''))
-        self.assertNotIn('foo', msgids)
-        self.assertNotIn('bar', msgids)
-
-    def test_calls_in_fstring_with_keyword_args(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_('foo', bar='baz')}"
-        '''))
-        self.assertNotIn('foo', msgids)
-        self.assertNotIn('bar', msgids)
-        self.assertNotIn('baz', msgids)
-
-    def test_calls_in_fstring_with_partially_wrong_expression(self):
-        msgids = self.extract_docstrings_from_str(dedent('''\
-        f"{_(f'foo') + _('bar')}"
-        '''))
-        self.assertNotIn('foo', msgids)
-        self.assertIn('bar', msgids)
-
-    def test_files_list(self):
-        """Make sure the directories are inspected for source files
-           bpo-31920
-        """
-        text1 = 'Text to translate1'
-        text2 = 'Text to translate2'
-        text3 = 'Text to ignore'
-        with temp_cwd(None), temp_dir(None) as sdir:
-            os.mkdir(os.path.join(sdir, 'pypkg'))
-            with open(os.path.join(sdir, 'pypkg', 'pymod.py'), 'w') as sfile:
-                sfile.write(f'_({text1!r})')
-            os.mkdir(os.path.join(sdir, 'pkg.py'))
-            with open(os.path.join(sdir, 'pkg.py', 'pymod2.py'), 'w') as sfile:
-                sfile.write(f'_({text2!r})')
-            os.mkdir(os.path.join(sdir, 'CVS'))
-            with open(os.path.join(sdir, 'CVS', 'pymod3.py'), 'w') as sfile:
-                sfile.write(f'_({text3!r})')
-            assert_python_ok(self.script, sdir)
-            with open('messages.pot') as fp:
-                data = fp.read()
-            self.assertIn(f'msgid "{text1}"', data)
-            self.assertIn(f'msgid "{text2}"', data)
-            self.assertNotIn(text3, data)

opt/plesk/python/3/lib/python3.10/test/test_tools/test_lll.py

@@ -1,41 +0,0 @@
-"""Tests for the lll script in the Tools/script directory."""
-
-import os
-import tempfile
-from test import support
-from test.support import os_helper
-from test.test_tools import skip_if_missing, import_tool
-import unittest
-
-skip_if_missing()
-
-
-class lllTests(unittest.TestCase):
-
-    def setUp(self):
-        self.lll = import_tool('lll')
-
-    @os_helper.skip_unless_symlink
-    def test_lll_multiple_dirs(self):
-        with tempfile.TemporaryDirectory() as dir1, \
-             tempfile.TemporaryDirectory() as dir2:
-            fn1 = os.path.join(dir1, 'foo1')
-            fn2 = os.path.join(dir2, 'foo2')
-            for fn, dir in (fn1, dir1), (fn2, dir2):
-                open(fn, 'w').close()
-                os.symlink(fn, os.path.join(dir, 'symlink'))
-
-            with support.captured_stdout() as output:
-                self.lll.main([dir1, dir2])
-            prefix = '\\\\?\\' if os.name == 'nt' else ''
-            self.assertEqual(output.getvalue(),
-                f'{dir1}:\n'
-                f'symlink -> {prefix}{fn1}\n'
-                f'\n'
-                f'{dir2}:\n'
-                f'symlink -> {prefix}{fn2}\n'
-            )
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_md5sum.py

@@ -1,79 +0,0 @@
-"""Tests for the md5sum script in the Tools directory."""
-
-import sys
-import os
-import unittest
-from test.support import os_helper
-from test.support import hashlib_helper
-from test.support.script_helper import assert_python_ok, assert_python_failure
-
-from test.test_tools import scriptsdir, skip_if_missing
-
-skip_if_missing()
-
-@hashlib_helper.requires_hashdigest('md5', openssl=True)
-class MD5SumTests(unittest.TestCase):
-    @classmethod
-    def setUpClass(cls):
-        cls.script = os.path.join(scriptsdir, 'md5sum.py')
-        os.mkdir(os_helper.TESTFN_ASCII)
-        cls.fodder = os.path.join(os_helper.TESTFN_ASCII, 'md5sum.fodder')
-        with open(cls.fodder, 'wb') as f:
-            f.write(b'md5sum\r\ntest file\r\n')
-        cls.fodder_md5 = b'd38dae2eb1ab346a292ef6850f9e1a0d'
-        cls.fodder_textmode_md5 = b'a8b07894e2ca3f2a4c3094065fa6e0a5'
-
-    @classmethod
-    def tearDownClass(cls):
-        os_helper.rmtree(os_helper.TESTFN_ASCII)
-
-    def test_noargs(self):
-        rc, out, err = assert_python_ok(self.script)
-        self.assertEqual(rc, 0)
-        self.assertTrue(
-            out.startswith(b'd41d8cd98f00b204e9800998ecf8427e <stdin>'))
-        self.assertFalse(err)
-
-    def test_checksum_fodder(self):
-        rc, out, err = assert_python_ok(self.script, self.fodder)
-        self.assertEqual(rc, 0)
-        self.assertTrue(out.startswith(self.fodder_md5))
-        for part in self.fodder.split(os.path.sep):
-            self.assertIn(part.encode(), out)
-        self.assertFalse(err)
-
-    def test_dash_l(self):
-        rc, out, err = assert_python_ok(self.script, '-l', self.fodder)
-        self.assertEqual(rc, 0)
-        self.assertIn(self.fodder_md5, out)
-        parts = self.fodder.split(os.path.sep)
-        self.assertIn(parts[-1].encode(), out)
-        self.assertNotIn(parts[-2].encode(), out)
-
-    def test_dash_t(self):
-        rc, out, err = assert_python_ok(self.script, '-t', self.fodder)
-        self.assertEqual(rc, 0)
-        self.assertTrue(out.startswith(self.fodder_textmode_md5))
-        self.assertNotIn(self.fodder_md5, out)
-
-    def test_dash_s(self):
-        rc, out, err = assert_python_ok(self.script, '-s', '512', self.fodder)
-        self.assertEqual(rc, 0)
-        self.assertIn(self.fodder_md5, out)
-
-    def test_multiple_files(self):
-        rc, out, err = assert_python_ok(self.script, self.fodder, self.fodder)
-        self.assertEqual(rc, 0)
-        lines = out.splitlines()
-        self.assertEqual(len(lines), 2)
-        self.assertEqual(*lines)
-
-    def test_usage(self):
-        rc, out, err = assert_python_failure(self.script, '-h')
-        self.assertEqual(rc, 2)
-        self.assertEqual(out, b'')
-        self.assertGreater(err, b'')
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_pathfix.py

@@ -1,132 +0,0 @@
-import os
-import subprocess
-import sys
-import unittest
-from test import support
-from test.support import os_helper
-from test.test_tools import scriptsdir, skip_if_missing
-
-
-# need Tools/script/ directory: skip if run on Python installed on the system
-skip_if_missing()
-
-
-class TestPathfixFunctional(unittest.TestCase):
-    script = os.path.join(scriptsdir, 'pathfix.py')
-
-    def setUp(self):
-        self.addCleanup(os_helper.unlink, os_helper.TESTFN)
-
-    def pathfix(self, shebang, pathfix_flags, exitcode=0, stdout='', stderr='',
-                directory=''):
-        if directory:
-            # bpo-38347: Test filename should contain lowercase, uppercase,
-            # "-", "_" and digits.
-            filename = os.path.join(directory, 'script-A_1.py')
-            pathfix_arg = directory
-        else:
-            filename = os_helper.TESTFN
-            pathfix_arg = filename
-
-        with open(filename, 'w', encoding='utf8') as f:
-            f.write(f'{shebang}\n' + 'print("Hello world")\n')
-
-        encoding = sys.getfilesystemencoding()
-        proc = subprocess.run(
-            [sys.executable, self.script,
-             *pathfix_flags, '-n', pathfix_arg],
-            env={**os.environ, 'PYTHONIOENCODING': encoding},
-            capture_output=True)
-
-        if stdout == '' and proc.returncode == 0:
-            stdout = f'{filename}: updating\n'
-        self.assertEqual(proc.returncode, exitcode, proc)
-        self.assertEqual(proc.stdout.decode(encoding), stdout.replace('\n', os.linesep), proc)
-        self.assertEqual(proc.stderr.decode(encoding), stderr.replace('\n', os.linesep), proc)
-
-        with open(filename, 'r', encoding='utf8') as f:
-            output = f.read()
-
-        lines = output.split('\n')
-        self.assertEqual(lines[1:], ['print("Hello world")', ''])
-        new_shebang = lines[0]
-
-        if proc.returncode != 0:
-            self.assertEqual(shebang, new_shebang)
-
-        return new_shebang
-
-    def test_recursive(self):
-        tmpdir = os_helper.TESTFN + '.d'
-        self.addCleanup(os_helper.rmtree, tmpdir)
-        os.mkdir(tmpdir)
-        expected_stderr = f"recursedown('{os.path.basename(tmpdir)}')\n"
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python',
-                ['-i', '/usr/bin/python3'],
-                directory=tmpdir,
-                stderr=expected_stderr),
-            '#! /usr/bin/python3')
-
-    def test_pathfix(self):
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python',
-                ['-i', '/usr/bin/python3']),
-            '#! /usr/bin/python3')
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python -R',
-                ['-i', '/usr/bin/python3']),
-            '#! /usr/bin/python3')
-
-    def test_pathfix_keeping_flags(self):
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python -R',
-                ['-i', '/usr/bin/python3', '-k']),
-            '#! /usr/bin/python3 -R')
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python',
-                ['-i', '/usr/bin/python3', '-k']),
-            '#! /usr/bin/python3')
-
-    def test_pathfix_adding_flag(self):
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python',
-                ['-i', '/usr/bin/python3', '-a', 's']),
-            '#! /usr/bin/python3 -s')
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python -S',
-                ['-i', '/usr/bin/python3', '-a', 's']),
-            '#! /usr/bin/python3 -s')
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python -V',
-                ['-i', '/usr/bin/python3', '-a', 'v', '-k']),
-            '#! /usr/bin/python3 -vV')
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python',
-                ['-i', '/usr/bin/python3', '-a', 'Rs']),
-            '#! /usr/bin/python3 -Rs')
-        self.assertEqual(
-            self.pathfix(
-                '#! /usr/bin/env python -W default',
-                ['-i', '/usr/bin/python3', '-a', 's', '-k']),
-            '#! /usr/bin/python3 -sW default')
-
-    def test_pathfix_adding_errors(self):
-        self.pathfix(
-            '#! /usr/bin/env python -E',
-            ['-i', '/usr/bin/python3', '-a', 'W default', '-k'],
-            exitcode=2,
-            stderr="-a option doesn't support whitespaces")
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_pdeps.py

@@ -1,32 +0,0 @@
-"""Tests for the pdeps script in the Tools directory."""
-
-import os
-import unittest
-import tempfile
-
-from test.test_tools import skip_if_missing, import_tool
-
-skip_if_missing()
-
-
-class PdepsTests(unittest.TestCase):
-
-    @classmethod
-    def setUpClass(self):
-        self.pdeps = import_tool('pdeps')
-
-    def test_process_errors(self):
-        # Issue #14492: m_import.match(line) can be None.
-        with tempfile.TemporaryDirectory() as tmpdir:
-            fn = os.path.join(tmpdir, 'foo')
-            with open(fn, 'w') as stream:
-                stream.write("#!/this/will/fail")
-            self.pdeps.process(fn, {})
-
-    def test_inverse_attribute_error(self):
-        # Issue #14492: this used to fail with an AttributeError.
-        self.pdeps.inverse({'a': []})
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_pindent.py

@@ -1,340 +0,0 @@
-"""Tests for the pindent script in the Tools directory."""
-
-import os
-import sys
-import unittest
-import subprocess
-import textwrap
-from test import support
-from test.support import os_helper
-from test.support.script_helper import assert_python_ok
-
-from test.test_tools import scriptsdir, skip_if_missing
-
-skip_if_missing()
-
-
-class PindentTests(unittest.TestCase):
-    script = os.path.join(scriptsdir, 'pindent.py')
-
-    def assertFileEqual(self, fn1, fn2):
-        with open(fn1) as f1, open(fn2) as f2:
-            self.assertEqual(f1.readlines(), f2.readlines())
-
-    def pindent(self, source, *args):
-        with subprocess.Popen(
-                (sys.executable, self.script) + args,
-                stdin=subprocess.PIPE, stdout=subprocess.PIPE,
-                universal_newlines=True) as proc:
-            out, err = proc.communicate(source)
-        self.assertIsNone(err)
-        return out
-
-    def lstriplines(self, data):
-        return '\n'.join(line.lstrip() for line in data.splitlines()) + '\n'
-
-    def test_selftest(self):
-        self.maxDiff = None
-        with os_helper.temp_dir() as directory:
-            data_path = os.path.join(directory, '_test.py')
-            with open(self.script) as f:
-                closed = f.read()
-            with open(data_path, 'w') as f:
-                f.write(closed)
-
-            rc, out, err = assert_python_ok(self.script, '-d', data_path)
-            self.assertEqual(out, b'')
-            self.assertEqual(err, b'')
-            backup = data_path + '~'
-            self.assertTrue(os.path.exists(backup))
-            with open(backup) as f:
-                self.assertEqual(f.read(), closed)
-            with open(data_path) as f:
-                clean = f.read()
-            compile(clean, '_test.py', 'exec')
-            self.assertEqual(self.pindent(clean, '-c'), closed)
-            self.assertEqual(self.pindent(closed, '-d'), clean)
-
-            rc, out, err = assert_python_ok(self.script, '-c', data_path)
-            self.assertEqual(out, b'')
-            self.assertEqual(err, b'')
-            with open(backup) as f:
-                self.assertEqual(f.read(), clean)
-            with open(data_path) as f:
-                self.assertEqual(f.read(), closed)
-
-            broken = self.lstriplines(closed)
-            with open(data_path, 'w') as f:
-                f.write(broken)
-            rc, out, err = assert_python_ok(self.script, '-r', data_path)
-            self.assertEqual(out, b'')
-            self.assertEqual(err, b'')
-            with open(backup) as f:
-                self.assertEqual(f.read(), broken)
-            with open(data_path) as f:
-                indented = f.read()
-            compile(indented, '_test.py', 'exec')
-            self.assertEqual(self.pindent(broken, '-r'), indented)
-
-    def pindent_test(self, clean, closed):
-        self.assertEqual(self.pindent(clean, '-c'), closed)
-        self.assertEqual(self.pindent(closed, '-d'), clean)
-        broken = self.lstriplines(closed)
-        self.assertEqual(self.pindent(broken, '-r', '-e', '-s', '4'), closed)
-
-    def test_statements(self):
-        clean = textwrap.dedent("""\
-            if a:
-                pass
-
-            if a:
-                pass
-            else:
-                pass
-
-            if a:
-                pass
-            elif:
-                pass
-            else:
-                pass
-
-            while a:
-                break
-
-            while a:
-                break
-            else:
-                pass
-
-            for i in a:
-                break
-
-            for i in a:
-                break
-            else:
-                pass
-
-            try:
-                pass
-            finally:
-                pass
-
-            try:
-                pass
-            except TypeError:
-                pass
-            except ValueError:
-                pass
-            else:
-                pass
-
-            try:
-                pass
-            except TypeError:
-                pass
-            except ValueError:
-                pass
-            finally:
-                pass
-
-            with a:
-                pass
-
-            class A:
-                pass
-
-            def f():
-                pass
-            """)
-
-        closed = textwrap.dedent("""\
-            if a:
-                pass
-            # end if
-
-            if a:
-                pass
-            else:
-                pass
-            # end if
-
-            if a:
-                pass
-            elif:
-                pass
-            else:
-                pass
-            # end if
-
-            while a:
-                break
-            # end while
-
-            while a:
-                break
-            else:
-                pass
-            # end while
-
-            for i in a:
-                break
-            # end for
-
-            for i in a:
-                break
-            else:
-                pass
-            # end for
-
-            try:
-                pass
-            finally:
-                pass
-            # end try
-
-            try:
-                pass
-            except TypeError:
-                pass
-            except ValueError:
-                pass
-            else:
-                pass
-            # end try
-
-            try:
-                pass
-            except TypeError:
-                pass
-            except ValueError:
-                pass
-            finally:
-                pass
-            # end try
-
-            with a:
-                pass
-            # end with
-
-            class A:
-                pass
-            # end class A
-
-            def f():
-                pass
-            # end def f
-            """)
-        self.pindent_test(clean, closed)
-
-    def test_multilevel(self):
-        clean = textwrap.dedent("""\
-            def foobar(a, b):
-                if a == b:
-                    a = a+1
-                elif a < b:
-                    b = b-1
-                    if b > a: a = a-1
-                else:
-                    print 'oops!'
-            """)
-        closed = textwrap.dedent("""\
-            def foobar(a, b):
-                if a == b:
-                    a = a+1
-                elif a < b:
-                    b = b-1
-                    if b > a: a = a-1
-                    # end if
-                else:
-                    print 'oops!'
-                # end if
-            # end def foobar
-            """)
-        self.pindent_test(clean, closed)
-
-    def test_preserve_indents(self):
-        clean = textwrap.dedent("""\
-            if a:
-                     if b:
-                              pass
-            """)
-        closed = textwrap.dedent("""\
-            if a:
-                     if b:
-                              pass
-                     # end if
-            # end if
-            """)
-        self.assertEqual(self.pindent(clean, '-c'), closed)
-        self.assertEqual(self.pindent(closed, '-d'), clean)
-        broken = self.lstriplines(closed)
-        self.assertEqual(self.pindent(broken, '-r', '-e', '-s', '9'), closed)
-        clean = textwrap.dedent("""\
-            if a:
-            \tif b:
-            \t\tpass
-            """)
-        closed = textwrap.dedent("""\
-            if a:
-            \tif b:
-            \t\tpass
-            \t# end if
-            # end if
-            """)
-        self.assertEqual(self.pindent(clean, '-c'), closed)
-        self.assertEqual(self.pindent(closed, '-d'), clean)
-        broken = self.lstriplines(closed)
-        self.assertEqual(self.pindent(broken, '-r'), closed)
-
-    def test_escaped_newline(self):
-        clean = textwrap.dedent("""\
-            class\\
-            \\
-             A:
-               def\
-            \\
-            f:
-                  pass
-            """)
-        closed = textwrap.dedent("""\
-            class\\
-            \\
-             A:
-               def\
-            \\
-            f:
-                  pass
-               # end def f
-            # end class A
-            """)
-        self.assertEqual(self.pindent(clean, '-c'), closed)
-        self.assertEqual(self.pindent(closed, '-d'), clean)
-
-    def test_empty_line(self):
-        clean = textwrap.dedent("""\
-            if a:
-
-                pass
-            """)
-        closed = textwrap.dedent("""\
-            if a:
-
-                pass
-            # end if
-            """)
-        self.pindent_test(clean, closed)
-
-    def test_oneline(self):
-        clean = textwrap.dedent("""\
-            if a: pass
-            """)
-        closed = textwrap.dedent("""\
-            if a: pass
-            # end if
-            """)
-        self.pindent_test(clean, closed)
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_reindent.py

@@ -1,35 +0,0 @@
-"""Tests for scripts in the Tools directory.
-
-This file contains regression tests for some of the scripts found in the
-Tools directory of a Python checkout or tarball, such as reindent.py.
-"""
-
-import os
-import unittest
-from test.support.script_helper import assert_python_ok
-from test.support import findfile
-
-from test.test_tools import scriptsdir, skip_if_missing
-
-skip_if_missing()
-
-class ReindentTests(unittest.TestCase):
-    script = os.path.join(scriptsdir, 'reindent.py')
-
-    def test_noargs(self):
-        assert_python_ok(self.script)
-
-    def test_help(self):
-        rc, out, err = assert_python_ok(self.script, '-h')
-        self.assertEqual(out, b'')
-        self.assertGreater(err, b'')
-
-    def test_reindent_file_with_bad_encoding(self):
-        bad_coding_path = findfile('bad_coding.py')
-        rc, out, err = assert_python_ok(self.script, '-r', bad_coding_path)
-        self.assertEqual(out, b'')
-        self.assertNotEqual(err, b'')
-
-
-if __name__ == '__main__':
-    unittest.main()

opt/plesk/python/3/lib/python3.10/test/test_tools/test_sundry.py

@@ -1,62 +0,0 @@
-"""Tests for scripts in the Tools directory.
-
-This file contains extremely basic regression tests for the scripts found in
-the Tools directory of a Python checkout or tarball which don't have separate
-tests of their own.
-"""
-
-import os
-import sys
-import unittest
-from test.support import import_helper
-
-from test.test_tools import scriptsdir, import_tool, skip_if_missing
-
-skip_if_missing()
-
-class TestSundryScripts(unittest.TestCase):
-    # At least make sure the rest don't have syntax errors.  When tests are
-    # added for a script it should be added to the allowlist below.
-
-    # scripts that have independent tests.
-    allowlist = ['reindent', 'pdeps', 'gprof2html', 'md5sum']
-    # scripts that can't be imported without running
-    denylist = ['make_ctype']
-    # scripts that use windows-only modules
-    windows_only = ['win_add2path']
-    # denylisted for other reasons
-    other = ['analyze_dxp', '2to3']
-
-    skiplist = denylist + allowlist + windows_only + other
-
-    def test_sundry(self):
-        old_modules = import_helper.modules_setup()
-        try:
-            for fn in os.listdir(scriptsdir):
-                if not fn.endswith('.py'):
-                    continue
-
-                name = fn[:-3]
-                if name in self.skiplist:
-                    continue
-
-                import_tool(name)
-        finally:
-            # Unload all modules loaded in this test
-            import_helper.modules_cleanup(*old_modules)
-
-    @unittest.skipIf(sys.platform != "win32", "Windows-only test")
-    def test_sundry_windows(self):
-        for name in self.windows_only:
-            import_tool(name)
-
-    def test_analyze_dxp_import(self):
-        if hasattr(sys, 'getdxp'):
-            import_tool('analyze_dxp')
-        else:
-            with self.assertRaises(RuntimeError):
-                import_tool('analyze_dxp')
-
-
-if __name__ == '__main__':
-    unittest.main()