| 1 |
import contextlib |
| 2 |
import dataclasses |
| 3 |
import json |
| 4 |
import os |
| 5 |
import shlex |
| 6 |
import subprocess |
| 7 |
import sys |
| 8 |
from typing import Any, Iterator |
| 9 |
|
| 10 |
from test import support |
| 11 |
|
| 12 |
from .utils import ( |
| 13 |
StrPath, StrJSON, TestTuple, TestName, TestFilter, FilterTuple, FilterDict) |
| 14 |
|
| 15 |
|
| 16 |
class JsonFileType: |
| 17 |
UNIX_FD = "UNIX_FD" |
| 18 |
WINDOWS_HANDLE = "WINDOWS_HANDLE" |
| 19 |
STDOUT = "STDOUT" |
| 20 |
|
| 21 |
|
| 22 |
@dataclasses.dataclass(slots=True, frozen=True) |
| 23 |
class JsonFile: |
| 24 |
# file type depends on file_type: |
| 25 |
# - UNIX_FD: file descriptor (int) |
| 26 |
# - WINDOWS_HANDLE: handle (int) |
| 27 |
# - STDOUT: use process stdout (None) |
| 28 |
file: int | None |
| 29 |
file_type: str |
| 30 |
|
| 31 |
def configure_subprocess(self, popen_kwargs: dict[str, Any]) -> None: |
| 32 |
match self.file_type: |
| 33 |
case JsonFileType.UNIX_FD: |
| 34 |
# Unix file descriptor |
| 35 |
popen_kwargs['pass_fds'] = [self.file] |
| 36 |
case JsonFileType.WINDOWS_HANDLE: |
| 37 |
# Windows handle |
| 38 |
# We run mypy with `--platform=linux` so it complains about this: |
| 39 |
startupinfo = subprocess.STARTUPINFO() # type: ignore[attr-defined] |
| 40 |
startupinfo.lpAttributeList = {"handle_list": [self.file]} |
| 41 |
popen_kwargs['startupinfo'] = startupinfo |
| 42 |
|
| 43 |
@contextlib.contextmanager |
| 44 |
def inherit_subprocess(self) -> Iterator[None]: |
| 45 |
if sys.platform == 'win32' and self.file_type == JsonFileType.WINDOWS_HANDLE: |
| 46 |
os.set_handle_inheritable(self.file, True) |
| 47 |
try: |
| 48 |
yield |
| 49 |
finally: |
| 50 |
os.set_handle_inheritable(self.file, False) |
| 51 |
else: |
| 52 |
yield |
| 53 |
|
| 54 |
def open(self, mode='r', *, encoding): |
| 55 |
if self.file_type == JsonFileType.STDOUT: |
| 56 |
raise ValueError("for STDOUT file type, just use sys.stdout") |
| 57 |
|
| 58 |
file = self.file |
| 59 |
if self.file_type == JsonFileType.WINDOWS_HANDLE: |
| 60 |
import msvcrt |
| 61 |
# Create a file descriptor from the handle |
| 62 |
file = msvcrt.open_osfhandle(file, os.O_WRONLY) |
| 63 |
return open(file, mode, encoding=encoding) |
| 64 |
|
| 65 |
|
| 66 |
@dataclasses.dataclass(slots=True, frozen=True) |
| 67 |
class HuntRefleak: |
| 68 |
warmups: int |
| 69 |
runs: int |
| 70 |
filename: StrPath |
| 71 |
|
| 72 |
def bisect_cmd_args(self) -> list[str]: |
| 73 |
# Ignore filename since it can contain colon (":"), |
| 74 |
# and usually it's not used. Use the default filename. |
| 75 |
return ["-R", f"{self.warmups}:{self.runs}:"] |
| 76 |
|
| 77 |
|
| 78 |
@dataclasses.dataclass(slots=True, frozen=True) |
| 79 |
class RunTests: |
| 80 |
tests: TestTuple |
| 81 |
fail_fast: bool |
| 82 |
fail_env_changed: bool |
| 83 |
match_tests: TestFilter |
| 84 |
match_tests_dict: FilterDict | None |
| 85 |
rerun: bool |
| 86 |
forever: bool |
| 87 |
pgo: bool |
| 88 |
pgo_extended: bool |
| 89 |
output_on_failure: bool |
| 90 |
timeout: float | None |
| 91 |
verbose: int |
| 92 |
quiet: bool |
| 93 |
hunt_refleak: HuntRefleak | None |
| 94 |
test_dir: StrPath | None |
| 95 |
use_junit: bool |
| 96 |
coverage: bool |
| 97 |
memory_limit: str | None |
| 98 |
gc_threshold: int | None |
| 99 |
use_resources: dict[str, str | None] |
| 100 |
python_cmd: tuple[str, ...] | None |
| 101 |
randomize: bool |
| 102 |
random_seed: int | str |
| 103 |
parallel_threads: int | None |
| 104 |
|
| 105 |
def copy(self, **override) -> 'RunTests': |
| 106 |
state = dataclasses.asdict(self) |
| 107 |
state.update(override) |
| 108 |
return RunTests(**state) |
| 109 |
|
| 110 |
def create_worker_runtests(self, **override) -> WorkerRunTests: |
| 111 |
state = dataclasses.asdict(self) |
| 112 |
state.update(override) |
| 113 |
return WorkerRunTests(**state) |
| 114 |
|
| 115 |
def get_match_tests(self, test_name: TestName) -> FilterTuple | None: |
| 116 |
if self.match_tests_dict is not None: |
| 117 |
return self.match_tests_dict.get(test_name, None) |
| 118 |
else: |
| 119 |
return None |
| 120 |
|
| 121 |
def get_jobs(self) -> int | None: |
| 122 |
# Number of run_single_test() calls needed to run all tests. |
| 123 |
# None means that there is not bound limit (--forever option). |
| 124 |
if self.forever: |
| 125 |
return None |
| 126 |
return len(self.tests) |
| 127 |
|
| 128 |
def iter_tests(self) -> Iterator[TestName]: |
| 129 |
if self.forever: |
| 130 |
while True: |
| 131 |
yield from self.tests |
| 132 |
else: |
| 133 |
yield from self.tests |
| 134 |
|
| 135 |
def json_file_use_stdout(self) -> bool: |
| 136 |
# Use STDOUT in two cases: |
| 137 |
# |
| 138 |
# - If --python command line option is used; |
| 139 |
# - On Emscripten and WASI. |
| 140 |
# |
| 141 |
# On other platforms, UNIX_FD or WINDOWS_HANDLE can be used. |
| 142 |
return ( |
| 143 |
bool(self.python_cmd) |
| 144 |
or support.is_emscripten |
| 145 |
or support.is_wasi |
| 146 |
) |
| 147 |
|
| 148 |
def create_python_cmd(self) -> list[str]: |
| 149 |
python_opts = support.args_from_interpreter_flags() |
| 150 |
if self.python_cmd is not None: |
| 151 |
executable = self.python_cmd |
| 152 |
# Remove -E option, since --python=COMMAND can set PYTHON |
| 153 |
# environment variables, such as PYTHONPATH, in the worker |
| 154 |
# process. |
| 155 |
python_opts = [opt for opt in python_opts if opt != "-E"] |
| 156 |
else: |
| 157 |
executable = (sys.executable,) |
| 158 |
cmd = [*executable, *python_opts] |
| 159 |
if '-u' not in python_opts: |
| 160 |
cmd.append('-u') # Unbuffered stdout and stderr |
| 161 |
if self.coverage: |
| 162 |
cmd.append("-Xpresite=test.cov") |
| 163 |
return cmd |
| 164 |
|
| 165 |
def bisect_cmd_args(self) -> list[str]: |
| 166 |
args = [] |
| 167 |
if self.fail_fast: |
| 168 |
args.append("--failfast") |
| 169 |
if self.fail_env_changed: |
| 170 |
args.append("--fail-env-changed") |
| 171 |
if self.timeout: |
| 172 |
args.append(f"--timeout={self.timeout}") |
| 173 |
if self.hunt_refleak is not None: |
| 174 |
args.extend(self.hunt_refleak.bisect_cmd_args()) |
| 175 |
if self.test_dir: |
| 176 |
args.extend(("--testdir", self.test_dir)) |
| 177 |
if self.memory_limit: |
| 178 |
args.extend(("--memlimit", self.memory_limit)) |
| 179 |
if self.gc_threshold: |
| 180 |
args.append(f"--threshold={self.gc_threshold}") |
| 181 |
if self.use_resources: |
| 182 |
simple = ','.join(resource |
| 183 |
for resource, value in self.use_resources.items() |
| 184 |
if value is None) |
| 185 |
if simple: |
| 186 |
args.extend(("-u", simple)) |
| 187 |
for resource, value in self.use_resources.items(): |
| 188 |
if value is not None: |
| 189 |
args.extend(("-u", f"{resource}={value}")) |
| 190 |
if self.python_cmd: |
| 191 |
cmd = shlex.join(self.python_cmd) |
| 192 |
args.extend(("--python", cmd)) |
| 193 |
if self.randomize: |
| 194 |
args.append(f"--randomize") |
| 195 |
if self.parallel_threads: |
| 196 |
args.append(f"--parallel-threads={self.parallel_threads}") |
| 197 |
args.append(f"--randseed={self.random_seed}") |
| 198 |
return args |
| 199 |
|
| 200 |
|
| 201 |
@dataclasses.dataclass(slots=True, frozen=True) |
| 202 |
class WorkerRunTests(RunTests): |
| 203 |
json_file: JsonFile |
| 204 |
|
| 205 |
def as_json(self) -> StrJSON: |
| 206 |
return json.dumps(self, cls=_EncodeRunTests) |
| 207 |
|
| 208 |
@staticmethod |
| 209 |
def from_json(worker_json: StrJSON) -> 'WorkerRunTests': |
| 210 |
return json.loads(worker_json, object_hook=_decode_runtests) |
| 211 |
|
| 212 |
|
| 213 |
class _EncodeRunTests(json.JSONEncoder): |
| 214 |
def default(self, o: Any) -> dict[str, Any]: |
| 215 |
if isinstance(o, WorkerRunTests): |
| 216 |
result = dataclasses.asdict(o) |
| 217 |
result["__runtests__"] = True |
| 218 |
return result |
| 219 |
else: |
| 220 |
return super().default(o) |
| 221 |
|
| 222 |
|
| 223 |
def _decode_runtests(data: dict[str, Any]) -> RunTests | dict[str, Any]: |
| 224 |
if "__runtests__" in data: |
| 225 |
data.pop('__runtests__') |
| 226 |
if data['hunt_refleak']: |
| 227 |
data['hunt_refleak'] = HuntRefleak(**data['hunt_refleak']) |
| 228 |
if data['json_file']: |
| 229 |
data['json_file'] = JsonFile(**data['json_file']) |
| 230 |
return WorkerRunTests(**data) |
| 231 |
else: |
| 232 |
return data |