← Back to branch summary

~ubuntu-branches/ubuntu/trusty/python3.4/trusty-proposed

« back to all changes in this revision

Viewing changes to Lib/test/script_helper.py

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-11-25 09:44:27 UTC
  • Revision ID: package-import@ubuntu.com-20131125094427-lzxj8ap5w01lmo7f
Tags: upstream-3.4~b1
Import upstream version 3.4~b1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Lib/test/script_helper.py
 
1
# Common utility functions used by various script execution tests
 
2
#  e.g. test_cmd_line, test_cmd_line_script and test_runpy
 
3
 
 
4
import importlib
 
5
import sys
 
6
import os
 
7
import os.path
 
8
import tempfile
 
9
import subprocess
 
10
import py_compile
 
11
import contextlib
 
12
import shutil
 
13
import zipfile
 
14
 
 
15
from importlib.util import source_from_cache
 
16
from test.support import make_legacy_pyc, strip_python_stderr, temp_dir
 
17
 
 
18
# Executing the interpreter in a subprocess
 
19
def _assert_python(expected_success, *args, **env_vars):
 
20
    if '__isolated' in env_vars:
 
21
        isolated = env_vars.pop('__isolated')
 
22
    else:
 
23
        isolated = not env_vars
 
24
    cmd_line = [sys.executable, '-X', 'faulthandler']
 
25
    if isolated:
 
26
        # isolated mode: ignore Python environment variables, ignore user
 
27
        # site-packages, and don't add the current directory to sys.path
 
28
        cmd_line.append('-I')
 
29
    elif not env_vars:
 
30
        # ignore Python environment variables
 
31
        cmd_line.append('-E')
 
32
    # Need to preserve the original environment, for in-place testing of
 
33
    # shared library builds.
 
34
    env = os.environ.copy()
 
35
    # But a special flag that can be set to override -- in this case, the
 
36
    # caller is responsible to pass the full environment.
 
37
    if env_vars.pop('__cleanenv', None):
 
38
        env = {}
 
39
    env.update(env_vars)
 
40
    cmd_line.extend(args)
 
41
    p = subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
 
42
                         stdout=subprocess.PIPE, stderr=subprocess.PIPE,
 
43
                         env=env)
 
44
    try:
 
45
        out, err = p.communicate()
 
46
    finally:
 
47
        subprocess._cleanup()
 
48
        p.stdout.close()
 
49
        p.stderr.close()
 
50
    rc = p.returncode
 
51
    err = strip_python_stderr(err)
 
52
    if (rc and expected_success) or (not rc and not expected_success):
 
53
        raise AssertionError(
 
54
            "Process return code is %d, "
 
55
            "stderr follows:\n%s" % (rc, err.decode('ascii', 'ignore')))
 
56
    return rc, out, err
 
57
 
 
58
def assert_python_ok(*args, **env_vars):
 
59
    """
 
60
    Assert that running the interpreter with `args` and optional environment
 
61
    variables `env_vars` succeeds (rc == 0) and return a (return code, stdout,
 
62
    stderr) tuple.
 
63
 
 
64
    If the __cleanenv keyword is set, env_vars is used a fresh environment.
 
65
 
 
66
    Python is started in isolated mode (command line option -I),
 
67
    except if the __isolated keyword is set to False.
 
68
    """
 
69
    return _assert_python(True, *args, **env_vars)
 
70
 
 
71
def assert_python_failure(*args, **env_vars):
 
72
    """
 
73
    Assert that running the interpreter with `args` and optional environment
 
74
    variables `env_vars` fails (rc != 0) and return a (return code, stdout,
 
75
    stderr) tuple.
 
76
 
 
77
    See assert_python_ok() for more options.
 
78
    """
 
79
    return _assert_python(False, *args, **env_vars)
 
80
 
 
81
def spawn_python(*args, **kw):
 
82
    """Run a Python subprocess with the given arguments.
 
83
 
 
84
    kw is extra keyword args to pass to subprocess.Popen. Returns a Popen
 
85
    object.
 
86
    """
 
87
    cmd_line = [sys.executable, '-E']
 
88
    cmd_line.extend(args)
 
89
    return subprocess.Popen(cmd_line, stdin=subprocess.PIPE,
 
90
                            stdout=subprocess.PIPE, stderr=subprocess.STDOUT,
 
91
                            **kw)
 
92
 
 
93
def kill_python(p):
 
94
    """Run the given Popen process until completion and return stdout."""
 
95
    p.stdin.close()
 
96
    data = p.stdout.read()
 
97
    p.stdout.close()
 
98
    # try to cleanup the child so we don't appear to leak when running
 
99
    # with regrtest -R.
 
100
    p.wait()
 
101
    subprocess._cleanup()
 
102
    return data
 
103
 
 
104
def make_script(script_dir, script_basename, source):
 
105
    script_filename = script_basename+os.extsep+'py'
 
106
    script_name = os.path.join(script_dir, script_filename)
 
107
    # The script should be encoded to UTF-8, the default string encoding
 
108
    script_file = open(script_name, 'w', encoding='utf-8')
 
109
    script_file.write(source)
 
110
    script_file.close()
 
111
    importlib.invalidate_caches()
 
112
    return script_name
 
113
 
 
114
def make_zip_script(zip_dir, zip_basename, script_name, name_in_zip=None):
 
115
    zip_filename = zip_basename+os.extsep+'zip'
 
116
    zip_name = os.path.join(zip_dir, zip_filename)
 
117
    zip_file = zipfile.ZipFile(zip_name, 'w')
 
118
    if name_in_zip is None:
 
119
        parts = script_name.split(os.sep)
 
120
        if len(parts) >= 2 and parts[-2] == '__pycache__':
 
121
            legacy_pyc = make_legacy_pyc(source_from_cache(script_name))
 
122
            name_in_zip = os.path.basename(legacy_pyc)
 
123
            script_name = legacy_pyc
 
124
        else:
 
125
            name_in_zip = os.path.basename(script_name)
 
126
    zip_file.write(script_name, name_in_zip)
 
127
    zip_file.close()
 
128
    #if test.support.verbose:
 
129
    #    zip_file = zipfile.ZipFile(zip_name, 'r')
 
130
    #    print 'Contents of %r:' % zip_name
 
131
    #    zip_file.printdir()
 
132
    #    zip_file.close()
 
133
    return zip_name, os.path.join(zip_name, name_in_zip)
 
134
 
 
135
def make_pkg(pkg_dir, init_source=''):
 
136
    os.mkdir(pkg_dir)
 
137
    make_script(pkg_dir, '__init__', init_source)
 
138
 
 
139
def make_zip_pkg(zip_dir, zip_basename, pkg_name, script_basename,
 
140
                 source, depth=1, compiled=False):
 
141
    unlink = []
 
142
    init_name = make_script(zip_dir, '__init__', '')
 
143
    unlink.append(init_name)
 
144
    init_basename = os.path.basename(init_name)
 
145
    script_name = make_script(zip_dir, script_basename, source)
 
146
    unlink.append(script_name)
 
147
    if compiled:
 
148
        init_name = py_compile(init_name, doraise=True)
 
149
        script_name = py_compile(script_name, doraise=True)
 
150
        unlink.extend((init_name, script_name))
 
151
    pkg_names = [os.sep.join([pkg_name]*i) for i in range(1, depth+1)]
 
152
    script_name_in_zip = os.path.join(pkg_names[-1], os.path.basename(script_name))
 
153
    zip_filename = zip_basename+os.extsep+'zip'
 
154
    zip_name = os.path.join(zip_dir, zip_filename)
 
155
    zip_file = zipfile.ZipFile(zip_name, 'w')
 
156
    for name in pkg_names:
 
157
        init_name_in_zip = os.path.join(name, init_basename)
 
158
        zip_file.write(init_name, init_name_in_zip)
 
159
    zip_file.write(script_name, script_name_in_zip)
 
160
    zip_file.close()
 
161
    for name in unlink:
 
162
        os.unlink(name)
 
163
    #if test.support.verbose:
 
164
    #    zip_file = zipfile.ZipFile(zip_name, 'r')
 
165
    #    print 'Contents of %r:' % zip_name
 
166
    #    zip_file.printdir()
 
167
    #    zip_file.close()
 
168
    return zip_name, os.path.join(zip_name, script_name_in_zip)