projects/linux·blob master · refs

381 lines · 19.5 KiB

1#!/usr/bin/env python3
2# SPDX-License-Identifier: GPL-2.0
3
4"""Tests the `rust_is_available.sh` script.
5
6Some of the tests require the real programs to be available in `$PATH`
7under their canonical name (and with the expected versions).
8"""
9
10import enum
11import os
12import pathlib
13import stat
14import subprocess
15import tempfile
16import unittest
17
18class TestRustIsAvailable(unittest.TestCase):
19 @enum.unique
20 class Expected(enum.Enum):
21 SUCCESS = enum.auto()
22 SUCCESS_WITH_WARNINGS = enum.auto()
23 SUCCESS_WITH_EXTRA_OUTPUT = enum.auto()
24 FAILURE = enum.auto()
25
26 @classmethod
27 def generate_executable(cls, content):
28 path = pathlib.Path(cls.tempdir.name)
29 name = str(len(tuple(path.iterdir())))
30 path = path / name
31 with open(path, "w") as file_:
32 file_.write(content)
33 os.chmod(path, os.stat(path).st_mode | stat.S_IXUSR)
34 return path
35
36 @classmethod
37 def generate_clang(cls, stdout):
38 return cls.generate_executable(f"""#!/usr/bin/env python3
39import sys
40if "-E" in " ".join(sys.argv):
41 print({repr("Clang " + " ".join(cls.llvm_default_version.split(" ")))})
42else:
43 print({repr(stdout)})
44""")
45
46 @classmethod
47 def generate_rustc(cls, stdout):
48 return cls.generate_executable(f"""#!/usr/bin/env python3
49import sys
50if "--print sysroot" in " ".join(sys.argv):
51 print({repr(cls.rust_default_sysroot)})
52else:
53 print({repr(stdout)})
54""")
55
56 @classmethod
57 def generate_bindgen(cls, version_stdout, libclang_stderr, libclang_22_patched=False):
58 if libclang_stderr is None:
59 libclang_case = f"raise SystemExit({cls.bindgen_default_bindgen_libclang_failure_exit_code})"
60 else:
61 libclang_case = f"print({repr(libclang_stderr)}, file=sys.stderr)"
62
63 if libclang_22_patched:
64 libclang_22_case = "print('pub foo: ::std::os::raw::c_int,')"
65 else:
66 libclang_22_case = "pass"
67
68 return cls.generate_executable(f"""#!/usr/bin/env python3
69import sys
70if "rust_is_available_bindgen_libclang.h" in " ".join(sys.argv):
71 {libclang_case}
72elif "rust_is_available_bindgen_libclang_22.h" in " ".join(sys.argv):
73 {libclang_22_case}
74else:
75 print({repr(version_stdout)})
76""")
77
78 @classmethod
79 def generate_bindgen_version(cls, stdout):
80 return cls.generate_bindgen(stdout, cls.bindgen_default_bindgen_libclang_stderr)
81
82 @classmethod
83 def generate_bindgen_libclang_failure(cls):
84 return cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, None)
85
86 @classmethod
87 def generate_bindgen_libclang(cls, stderr):
88 return cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, stderr)
89
90 @classmethod
91 def setUpClass(cls):
92 cls.tempdir = tempfile.TemporaryDirectory()
93
94 cls.missing = pathlib.Path(cls.tempdir.name) / "missing"
95
96 cls.nonexecutable = pathlib.Path(cls.tempdir.name) / "nonexecutable"
97 with open(cls.nonexecutable, "w") as file_:
98 file_.write("nonexecutable")
99
100 cls.unexpected_binary = "true"
101
102 cls.rustc_default_version = subprocess.check_output(("scripts/min-tool-version.sh", "rustc")).decode().strip()
103 cls.bindgen_default_version = subprocess.check_output(("scripts/min-tool-version.sh", "bindgen")).decode().strip()
104 cls.llvm_default_version = subprocess.check_output(("scripts/min-tool-version.sh", "llvm")).decode().strip()
105 cls.rust_default_sysroot = subprocess.check_output(("rustc", "--print", "sysroot")).decode().strip()
106
107 cls.bindgen_default_bindgen_version_stdout = f"bindgen {cls.bindgen_default_version}"
108 cls.bindgen_default_bindgen_libclang_failure_exit_code = 42
109 cls.bindgen_default_bindgen_libclang_stderr = f"scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {cls.llvm_default_version} [-W#pragma-messages], err: false"
110
111 cls.default_rustc = cls.generate_rustc(f"rustc {cls.rustc_default_version}")
112 cls.default_bindgen = cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, cls.bindgen_default_bindgen_libclang_stderr)
113 cls.default_cc = cls.generate_clang(f"clang version {cls.llvm_default_version}")
114
115 def run_script(self, expected, override_env):
116 env = {
117 "RUSTC": self.default_rustc,
118 "BINDGEN": self.default_bindgen,
119 "CC": self.default_cc,
120 }
121
122 for key, value in override_env.items():
123 if value is None:
124 del env[key]
125 continue
126 env[key] = value
127
128 result = subprocess.run("scripts/rust_is_available.sh", env=env, capture_output=True)
129
130 # The script should never output anything to `stdout`.
131 self.assertEqual(result.stdout, b"")
132
133 if expected == self.Expected.SUCCESS:
134 # When expecting a success, the script should return 0
135 # and it should not output anything to `stderr`.
136 self.assertEqual(result.returncode, 0)
137 self.assertEqual(result.stderr, b"")
138 elif expected == self.Expected.SUCCESS_WITH_EXTRA_OUTPUT:
139 # When expecting a success with extra output (that is not warnings,
140 # which is the common case), the script should return 0 and it
141 # should output at least something to `stderr` (the output should
142 # be checked further by the test).
143 self.assertEqual(result.returncode, 0)
144 self.assertNotEqual(result.stderr, b"")
145 elif expected == self.Expected.SUCCESS_WITH_WARNINGS:
146 # When expecting a success with warnings, the script should return 0
147 # and it should output at least the instructions to `stderr`.
148 self.assertEqual(result.returncode, 0)
149 self.assertIn(b"Please see Documentation/rust/quick-start.rst for details", result.stderr)
150 else:
151 # When expecting a failure, the script should return non-0
152 # and it should output at least the instructions to `stderr`.
153 self.assertNotEqual(result.returncode, 0)
154 self.assertIn(b"Please see Documentation/rust/quick-start.rst for details", result.stderr)
155
156 # The output will generally be UTF-8 (i.e. unless the user has
157 # put strange values in the environment).
158 result.stderr = result.stderr.decode()
159
160 return result
161
162 def test_rustc_unset(self):
163 result = self.run_script(self.Expected.FAILURE, { "RUSTC": None })
164 self.assertIn("Environment variable 'RUSTC' is not set.", result.stderr)
165 self.assertIn("This script is intended to be called from Kbuild.", result.stderr)
166
167 def test_bindgen_unset(self):
168 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": None })
169 self.assertIn("Environment variable 'BINDGEN' is not set.", result.stderr)
170 self.assertIn("This script is intended to be called from Kbuild.", result.stderr)
171
172 def test_cc_unset(self):
173 result = self.run_script(self.Expected.FAILURE, { "CC": None })
174 self.assertIn("Environment variable 'CC' is not set.", result.stderr)
175 self.assertIn("This script is intended to be called from Kbuild.", result.stderr)
176
177 def test_rustc_missing(self):
178 result = self.run_script(self.Expected.FAILURE, { "RUSTC": self.missing })
179 self.assertIn(f"Rust compiler '{self.missing}' could not be found.", result.stderr)
180
181 def test_bindgen_missing(self):
182 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.missing })
183 self.assertIn(f"Rust bindings generator '{self.missing}' could not be found.", result.stderr)
184
185 def test_rustc_nonexecutable(self):
186 result = self.run_script(self.Expected.FAILURE, { "RUSTC": self.nonexecutable })
187 self.assertTrue(
188 # `dash`.
189 f"Running '{self.nonexecutable}' to check the Rust compiler version failed with" in result.stderr or
190 # `bash`.
191 f"Rust compiler '{self.nonexecutable}' could not be found." in result.stderr,
192 f"Unexpected `stderr`:\n{result.stderr}"
193 )
194
195 def test_rustc_unexpected_binary(self):
196 result = self.run_script(self.Expected.FAILURE, { "RUSTC": self.unexpected_binary })
197 self.assertIn(f"Running '{self.unexpected_binary}' to check the Rust compiler version did not return", result.stderr)
198
199 def test_rustc_unexpected_name(self):
200 rustc = self.generate_rustc(f"unexpected {self.rustc_default_version} (a8314ef7d 2022-06-27)")
201 result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
202 self.assertIn(f"Running '{rustc}' to check the Rust compiler version did not return", result.stderr)
203
204 def test_rustc_unexpected_version(self):
205 rustc = self.generate_rustc("rustc unexpected (a8314ef7d 2022-06-27)")
206 result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
207 self.assertIn(f"Running '{rustc}' to check the Rust compiler version did not return", result.stderr)
208
209 def test_rustc_no_minor(self):
210 rustc = self.generate_rustc(f"rustc {'.'.join(self.rustc_default_version.split('.')[:2])} (a8314ef7d 2022-06-27)")
211 result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
212 self.assertIn(f"Running '{rustc}' to check the Rust compiler version did not return", result.stderr)
213
214 def test_rustc_old_version(self):
215 rustc = self.generate_rustc("rustc 1.60.0 (a8314ef7d 2022-06-27)")
216 result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
217 self.assertIn(f"Rust compiler '{rustc}' is too old.", result.stderr)
218
219 def test_bindgen_nonexecutable(self):
220 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.nonexecutable })
221 self.assertTrue(
222 # `dash`.
223 f"Running '{self.nonexecutable}' to check the Rust bindings generator version failed with" in result.stderr or
224 # `bash`.
225 f"Rust bindings generator '{self.nonexecutable}' could not be found." in result.stderr,
226 f"Unexpected `stderr`:\n{result.stderr}"
227 )
228
229 def test_bindgen_unexpected_binary(self):
230 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.unexpected_binary })
231 self.assertIn(f"Running '{self.unexpected_binary}' to check the bindings generator version did not return", result.stderr)
232
233 def test_bindgen_unexpected_name(self):
234 bindgen = self.generate_bindgen_version(f"unexpected {self.bindgen_default_version}")
235 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
236 self.assertIn(f"Running '{bindgen}' to check the bindings generator version did not return", result.stderr)
237
238 def test_bindgen_unexpected_version(self):
239 bindgen = self.generate_bindgen_version("bindgen unexpected")
240 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
241 self.assertIn(f"Running '{bindgen}' to check the bindings generator version did not return", result.stderr)
242
243 def test_bindgen_no_minor(self):
244 bindgen = self.generate_bindgen_version(f"bindgen {'.'.join(self.bindgen_default_version.split('.')[:2])}")
245 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
246 self.assertIn(f"Running '{bindgen}' to check the bindings generator version did not return", result.stderr)
247
248 def test_bindgen_old_version(self):
249 bindgen = self.generate_bindgen_version("bindgen 0.50.0")
250 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
251 self.assertIn(f"Rust bindings generator '{bindgen}' is too old.", result.stderr)
252
253 def test_bindgen_libclang_failure(self):
254 bindgen = self.generate_bindgen_libclang_failure()
255 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
256 self.assertIn(f"Running '{bindgen}' to check the libclang version (used by the Rust", result.stderr)
257 self.assertIn(f"bindings generator) failed with code {self.bindgen_default_bindgen_libclang_failure_exit_code}. This may be caused by", result.stderr)
258
259 def test_bindgen_libclang_unexpected_version(self):
260 bindgen = self.generate_bindgen_libclang("scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version unexpected [-W#pragma-messages], err: false")
261 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
262 self.assertIn(f"Running '{bindgen}' to check the libclang version (used by the Rust", result.stderr)
263 self.assertIn("bindings generator) did not return an expected output. See output", result.stderr)
264
265 def test_bindgen_libclang_old_version(self):
266 bindgen = self.generate_bindgen_libclang("scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version 10.0.0 [-W#pragma-messages], err: false")
267 result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
268 self.assertIn(f"libclang (used by the Rust bindings generator '{bindgen}') is too old.", result.stderr)
269
270 def test_bindgen_bad_libclang_22(self):
271 for (bindgen_version, libclang_version, expected_not_patched) in (
272 ("0.71.1", "21.1.0", self.Expected.SUCCESS),
273 ("0.71.1", "22.0.0", self.Expected.SUCCESS_WITH_WARNINGS),
274 ("0.71.1", "22.1.0", self.Expected.SUCCESS_WITH_WARNINGS),
275
276 ("0.72.0", "22.0.0", self.Expected.SUCCESS_WITH_WARNINGS),
277
278 ("0.72.1", "22.0.0", self.Expected.SUCCESS),
279 ):
280 with self.subTest(bindgen_version=bindgen_version, libclang_version=libclang_version):
281 cc = self.generate_clang(f"clang version {libclang_version}")
282 libclang_stderr = f"scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {libclang_version} [-W#pragma-messages], err: false"
283 bindgen = self.generate_bindgen(f"bindgen {bindgen_version}", libclang_stderr)
284 result = self.run_script(expected_not_patched, { "BINDGEN": bindgen, "CC": cc })
285 if expected_not_patched == self.Expected.SUCCESS_WITH_WARNINGS:
286 self.assertIn(f"Rust bindings generator '{bindgen}' < 0.72.1 together with libclang >= 22", result.stderr)
287
288 bindgen = self.generate_bindgen(f"bindgen {bindgen_version}", libclang_stderr, libclang_22_patched=True)
289 result = self.run_script(self.Expected.SUCCESS, { "BINDGEN": bindgen, "CC": cc })
290
291 def test_clang_matches_bindgen_libclang_different_bindgen(self):
292 bindgen = self.generate_bindgen_libclang("scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version 999.0.0 [-W#pragma-messages], err: false")
293 result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen })
294 self.assertIn("version does not match Clang's. This may be a problem.", result.stderr)
295
296 def test_clang_matches_bindgen_libclang_different_clang(self):
297 cc = self.generate_clang("clang version 999.0.0")
298 result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "CC": cc })
299 self.assertIn("version does not match Clang's. This may be a problem.", result.stderr)
300
301 def test_rustc_src_core_krustflags(self):
302 result = self.run_script(self.Expected.FAILURE, { "PATH": os.environ["PATH"], "RUSTC": "rustc", "KRUSTFLAGS": f"--sysroot={self.missing}" })
303 self.assertIn("Source code for the 'core' standard library could not be found", result.stderr)
304
305 def test_rustc_src_core_rustlibsrc(self):
306 result = self.run_script(self.Expected.FAILURE, { "RUST_LIB_SRC": self.missing })
307 self.assertIn("Source code for the 'core' standard library could not be found", result.stderr)
308
309 def test_success_cc_unknown(self):
310 result = self.run_script(self.Expected.SUCCESS_WITH_EXTRA_OUTPUT, { "CC": self.missing })
311 self.assertIn("unknown C compiler", result.stderr)
312
313 def test_success_cc_multiple_arguments_ccache(self):
314 clang = self.generate_clang(f"""Ubuntu clang version {self.llvm_default_version}-1ubuntu1
315Target: x86_64-pc-linux-gnu
316Thread model: posix
317InstalledDir: /usr/bin
318""")
319 result = self.run_script(self.Expected.SUCCESS, { "CC": f"{clang} clang" })
320
321 def test_success_rustc_version(self):
322 for rustc_stdout in (
323 f"rustc {self.rustc_default_version} (a8314ef7d 2022-06-27)",
324 f"rustc {self.rustc_default_version}-dev (a8314ef7d 2022-06-27)",
325 f"rustc {self.rustc_default_version}-1.60.0 (a8314ef7d 2022-06-27)",
326 ):
327 with self.subTest(rustc_stdout=rustc_stdout):
328 rustc = self.generate_rustc(rustc_stdout)
329 result = self.run_script(self.Expected.SUCCESS, { "RUSTC": rustc })
330
331 def test_success_bindgen_version(self):
332 for bindgen_stdout in (
333 f"bindgen {self.bindgen_default_version}",
334 f"bindgen {self.bindgen_default_version}-dev",
335 f"bindgen {self.bindgen_default_version}-0.999.0",
336 ):
337 with self.subTest(bindgen_stdout=bindgen_stdout):
338 bindgen = self.generate_bindgen_version(bindgen_stdout)
339 result = self.run_script(self.Expected.SUCCESS, { "BINDGEN": bindgen })
340
341 def test_success_bindgen_libclang(self):
342 for stderr in (
343 f"scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {self.llvm_default_version} (https://github.com/llvm/llvm-project.git 4a2c05b05ed07f1f620e94f6524a8b4b2760a0b1) [-W#pragma-messages], err: false",
344 f"/home/jd/Documents/dev/kernel-module-flake/linux-6.1/outputs/dev/lib/modules/6.1.0-development/source/scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {self.llvm_default_version} [-W#pragma-messages], err: false",
345 f"scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {self.llvm_default_version} (Fedora 13.0.0-3.fc35) [-W#pragma-messages], err: false",
346 f"""
347/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin/bash: warning: setlocale: LC_ALL: cannot change locale (c)
348scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {self.llvm_default_version} [-W#pragma-messages], err: false
349""",
350 f"""
351/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1.0-p16/bin/bash: warning: setlocale: LC_ALL: cannot change locale (c)
352/home/jd/Documents/dev/kernel-module-flake/linux-6.1/outputs/dev/lib/modules/6.1.0-development/source/scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {self.llvm_default_version} (Fedora 13.0.0-3.fc35) [-W#pragma-messages], err: false
353"""
354 ):
355 with self.subTest(stderr=stderr):
356 bindgen = self.generate_bindgen_libclang(stderr)
357 result = self.run_script(self.Expected.SUCCESS, { "BINDGEN": bindgen })
358
359 def test_success_clang_version(self):
360 for clang_stdout in (
361 f"clang version {self.llvm_default_version} (https://github.com/llvm/llvm-project.git 4a2c05b05ed07f1f620e94f6524a8b4b2760a0b1)",
362 f"clang version {self.llvm_default_version}-dev",
363 f"clang version {self.llvm_default_version}-2~ubuntu20.04.1",
364 f"Ubuntu clang version {self.llvm_default_version}-2~ubuntu20.04.1",
365 ):
366 with self.subTest(clang_stdout=clang_stdout):
367 clang = self.generate_clang(clang_stdout)
368 result = self.run_script(self.Expected.SUCCESS, { "CC": clang })
369
370 def test_success_real_programs(self):
371 for cc in ["gcc", "clang"]:
372 with self.subTest(cc=cc):
373 result = self.run_script(self.Expected.SUCCESS, {
374 "PATH": os.environ["PATH"],
375 "RUSTC": "rustc",
376 "BINDGEN": "bindgen",
377 "CC": cc,
378 })
379
380if __name__ == "__main__":
381 unittest.main()