FM / tests

/opt/cloudlinux/venv/lib/python3.11/site-packages/setuptools/tests/

/opt/cloudlinux/venv/lib/python3.11/site-packages/setuptools/tests

Name	Size	Mode	Actions
compat/	-	0755	rm
config/	-	0755	rm
indexes/	-	0755	rm
integration/	-	0755	rm
__pycache__/	-	0755	rm
contexts.py	3166	0644	edit dl rm
environment.py	3102	0644	edit dl rm
fixtures.py	12224	0644	edit dl rm
mod_with_constant.py	22	0644	edit dl rm
namespaces.py	2774	0644	edit dl rm
script-with-bom.py	18	0644	edit dl rm
test_archive_util.py	845	0644	edit dl rm
test_bdist_deprecations.py	775	0644	edit dl rm
test_bdist_egg.py	1957	0644	edit dl rm
test_bdist_wheel.py	23091	0644	edit dl rm
test_build.py	798	0644	edit dl rm
test_build_clib.py	3123	0644	edit dl rm
test_build_ext.py	10099	0644	edit dl rm
test_build_meta.py	33320	0644	edit dl rm
test_build_py.py	14201	0644	edit dl rm
test_config_discovery.py	22580	0644	edit dl rm
test_core_metadata.py	18038	0644	edit dl rm
test_depends.py	424	0644	edit dl rm
test_develop.py	3072	0644	edit dl rm
test_dist.py	8951	0644	edit dl rm
test_distutils_adoption.py	5987	0644	edit dl rm
test_dist_info.py	5005	0644	edit dl rm
test_editable_install.py	42619	0644	edit dl rm
test_egg_info.py	44941	0644	edit dl rm
test_extern.py	296	0644	edit dl rm
test_find_packages.py	7819	0644	edit dl rm
test_find_py_modules.py	2404	0644	edit dl rm
test_glob.py	887	0644	edit dl rm
test_install_scripts.py	3433	0644	edit dl rm
test_logging.py	2096	0644	edit dl rm
test_manifest.py	18562	0644	edit dl rm
test_namespaces.py	4515	0644	edit dl rm
test_scripts.py	379	0644	edit dl rm
test_sdist.py	32808	0644	edit dl rm
test_setopt.py	1365	0644	edit dl rm
test_setuptools.py	9008	0644	edit dl rm
test_shutil_wrapper.py	641	0644	edit dl rm
test_unicode_utils.py	316	0644	edit dl rm
test_virtualenv.py	3730	0644	edit dl rm
test_warnings.py	3347	0644	edit dl rm
test_wheel.py	18722	0644	edit dl rm
test_windows_wrappers.py	7868	0644	edit dl rm
text.py	123	0644	edit dl rm
textwrap.py	98	0644	edit dl rm
__init__.py	335	0644	edit dl rm

Edit: /opt/cloudlinux/venv/lib/python3.11/site-packages/setuptools/tests/test_windows_wrappers.py (7868B)

"""
Python Script Wrapper for Windows
=================================

setuptools includes wrappers for Python scripts that allows them to be
executed like regular windows programs.  There are 2 wrappers, one
for command-line programs, cli.exe, and one for graphical programs,
gui.exe.  These programs are almost identical, function pretty much
the same way, and are generated from the same source file.  The
wrapper programs are used by copying them to the directory containing
the script they are to wrap and with the same name as the script they
are to wrap.
"""

import pathlib
import platform
import subprocess
import sys
import textwrap

import pytest

from setuptools._importlib import resources

pytestmark = pytest.mark.skipif(sys.platform != 'win32', reason="Windows only")

class WrapperTester:
    @classmethod
    def prep_script(cls, template):
        python_exe = subprocess.list2cmdline([sys.executable])
        return template % locals()

@classmethod
    def create_script(cls, tmpdir):
        """
        Create a simple script, foo-script.py

Note that the script starts with a Unix-style '#!' line saying which
        Python executable to run.  The wrapper will use this line to find the
        correct Python executable.
        """

script = cls.prep_script(cls.script_tmpl)

with (tmpdir / cls.script_name).open('w') as f:
            f.write(script)

# also copy cli.exe to the sample directory
        with (tmpdir / cls.wrapper_name).open('wb') as f:
            w = resources.files('setuptools').joinpath(cls.wrapper_source).read_bytes()
            f.write(w)

def win_launcher_exe(prefix):
    """A simple routine to select launcher script based on platform."""
    assert prefix in ('cli', 'gui')
    if platform.machine() == "ARM64":
        return f"{prefix}-arm64.exe"
    else:
        return f"{prefix}-32.exe"

class TestCLI(WrapperTester):
    script_name = 'foo-script.py'
    wrapper_name = 'foo.exe'
    wrapper_source = win_launcher_exe('cli')

script_tmpl = textwrap.dedent(
        """
        #!%(python_exe)s
        import sys
        input = repr(sys.stdin.read())
        print(sys.argv[0][-14:])
        print(sys.argv[1:])
        print(input)
        if __debug__:
            print('non-optimized')
        """
    ).lstrip()

def test_basic(self, tmpdir):
        """
        When the copy of cli.exe, foo.exe in this example, runs, it examines
        the path name it was run with and computes a Python script path name
        by removing the '.exe' suffix and adding the '-script.py' suffix. (For
        GUI programs, the suffix '-script.pyw' is added.)  This is why we
        named out script the way we did.  Now we can run out script by running
        the wrapper:

This example was a little pathological in that it exercised windows
        (MS C runtime) quoting rules:

- Strings containing spaces are surrounded by double quotes.

- Double quotes in strings need to be escaped by preceding them with
          back slashes.

- One or more backslashes preceding double quotes need to be escaped
          by preceding each of them with back slashes.
        """
        self.create_script(tmpdir)
        cmd = [
            str(tmpdir / 'foo.exe'),
            'arg1',
            'arg 2',
            'arg "2\\"',
            'arg 4\\',
            'arg5 a\\\\b',
        ]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            text=True,
            encoding="utf-8",
        )
        stdout, _stderr = proc.communicate('hello\nworld\n')
        actual = stdout.replace('\r\n', '\n')
        expected = textwrap.dedent(
            r"""
            \foo-script.py
            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
            'hello\nworld\n'
            non-optimized
            """
        ).lstrip()
        assert actual == expected

def test_symlink(self, tmpdir):
        """
        Ensure that symlink for the foo.exe is working correctly.
        """
        script_dir = tmpdir / "script_dir"
        script_dir.mkdir()
        self.create_script(script_dir)
        symlink = pathlib.Path(tmpdir / "foo.exe")
        symlink.symlink_to(script_dir / "foo.exe")

cmd = [
            str(tmpdir / 'foo.exe'),
            'arg1',
            'arg 2',
            'arg "2\\"',
            'arg 4\\',
            'arg5 a\\\\b',
        ]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            text=True,
            encoding="utf-8",
        )
        stdout, _stderr = proc.communicate('hello\nworld\n')
        actual = stdout.replace('\r\n', '\n')
        expected = textwrap.dedent(
            r"""
            \foo-script.py
            ['arg1', 'arg 2', 'arg "2\\"', 'arg 4\\', 'arg5 a\\\\b']
            'hello\nworld\n'
            non-optimized
            """
        ).lstrip()
        assert actual == expected

def test_with_options(self, tmpdir):
        """
        Specifying Python Command-line Options
        --------------------------------------

You can specify a single argument on the '#!' line.  This can be used
        to specify Python options like -O, to run in optimized mode or -i
        to start the interactive interpreter.  You can combine multiple
        options as usual. For example, to run in optimized mode and
        enter the interpreter after running the script, you could use -Oi:
        """
        self.create_script(tmpdir)
        tmpl = textwrap.dedent(
            """
            #!%(python_exe)s  -Oi
            import sys
            input = repr(sys.stdin.read())
            print(sys.argv[0][-14:])
            print(sys.argv[1:])
            print(input)
            if __debug__:
                print('non-optimized')
            sys.ps1 = '---'
            """
        ).lstrip()
        with (tmpdir / 'foo-script.py').open('w') as f:
            f.write(self.prep_script(tmpl))
        cmd = [str(tmpdir / 'foo.exe')]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
            encoding="utf-8",
        )
        stdout, _stderr = proc.communicate()
        actual = stdout.replace('\r\n', '\n')
        expected = textwrap.dedent(
            r"""
            \foo-script.py
            []
            ''
            ---
            """
        ).lstrip()
        assert actual == expected

class TestGUI(WrapperTester):
    """
    Testing the GUI Version
    -----------------------
    """

script_name = 'bar-script.pyw'
    wrapper_source = win_launcher_exe('gui')
    wrapper_name = 'bar.exe'

script_tmpl = textwrap.dedent(
        """
        #!%(python_exe)s
        import sys
        f = open(sys.argv[1], 'wb')
        bytes_written = f.write(repr(sys.argv[2]).encode('utf-8'))
        f.close()
        """
    ).strip()

def test_basic(self, tmpdir):
        """Test the GUI version with the simple script, bar-script.py"""
        self.create_script(tmpdir)

cmd = [
            str(tmpdir / 'bar.exe'),
            str(tmpdir / 'test_output.txt'),
            'Test Argument',
        ]
        proc = subprocess.Popen(
            cmd,
            stdout=subprocess.PIPE,
            stdin=subprocess.PIPE,
            stderr=subprocess.STDOUT,
            text=True,
            encoding="utf-8",
        )
        stdout, stderr = proc.communicate()
        assert not stdout
        assert not stderr
        with (tmpdir / 'test_output.txt').open('rb') as f_out:
            actual = f_out.read().decode('ascii')
        assert actual == repr('Test Argument')

cmd: