Debian Codegraph @

Lib/test/libregrtest/runtests.py

raw
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