Gecko [ www.utparral.edu.mx ]

Name	Size	Permission
atomic	[ DIR ]	drwxr-xr-x
basic	[ DIR ]	drwxr-xr-x
clang-tools	[ DIR ]	drwxr-xr-x
coccinelle	[ DIR ]	drwxr-xr-x
dtc	[ DIR ]	drwxr-xr-x
dummy-tools	[ DIR ]	drwxr-xr-x
gcc-plugins	[ DIR ]	drwxr-xr-x
gdb	[ DIR ]	drwxr-xr-x
genksyms	[ DIR ]	drwxr-xr-x
kconfig	[ DIR ]	drwxr-xr-x
ksymoops	[ DIR ]	drwxr-xr-x
mod	[ DIR ]	drwxr-xr-x
package	[ DIR ]	drwxr-xr-x
selinux	[ DIR ]	drwxr-xr-x
tracing	[ DIR ]	drwxr-xr-x
asn1_compiler	34.25 KB	-rwxr-xr-x
asn1_compiler.c	35.32 KB	-rw-r--r--
as-version.sh	2.03 KB	-rwxr-xr-x
bloat-o-meter	3.77 KB	-rwxr-xr-x
bootgraph.pl	5.64 KB	-rwxr-xr-x
bpf_doc.py	31.73 KB	-rwxr-xr-x
cc-can-link.sh	166 B	-rwxr-xr-x
cc-version.sh	1.36 KB	-rwxr-xr-x
checkdeclares.pl	1.1 KB	-rwxr-xr-x
check_extable.sh	4.93 KB	-rwxr-xr-x
check-git	298 B	-rwxr-xr-x
checkincludes.pl	1.94 KB	-rwxr-xr-x
checkkconfigsymbols.py	15.75 KB	-rwxr-xr-x
checkpatch.pl	233.78 KB	-rwxr-xr-x
checkstack.pl	5.96 KB	-rwxr-xr-x
checksyscalls.sh	7.51 KB	-rwxr-xr-x
check-sysctl-docs	3.66 KB	-rwxr-xr-x
check-uapi.sh	15.05 KB	-rwxr-xr-x
checkversion.pl	2.16 KB	-rwxr-xr-x
cleanfile	3.46 KB	-rwxr-xr-x
cleanpatch	5.06 KB	-rwxr-xr-x
coccicheck	7.9 KB	-rwxr-xr-x
config	4.67 KB	-rwxr-xr-x
const_structs.checkpatch	1.4 KB	-rw-r--r--
decodecode	4.86 KB	-rwxr-xr-x
decode_stacktrace.sh	7.58 KB	-rwxr-xr-x
depmod.sh	697 B	-rwxr-xr-x
dev-needs.sh	6.07 KB	-rwxr-xr-x
diffconfig	4.12 KB	-rwxr-xr-x
documentation-file-ref-check	5.67 KB	-rwxr-xr-x
export_report.pl	4.5 KB	-rwxr-xr-x
extract-ikconfig	1.74 KB	-rwxr-xr-x
extract-module-sig.pl	3.66 KB	-rwxr-xr-x
extract-sys-certs.pl	3.75 KB	-rwxr-xr-x
extract-vmlinux	1.66 KB	-rwxr-xr-x
extract_xc3028.pl	44.62 KB	-rwxr-xr-x
faddr2line	8.63 KB	-rwxr-xr-x
file-size.sh	86 B	-rwxr-xr-x
find-unused-docs.sh	1.27 KB	-rwxr-xr-x
gcc-x86_32-has-stack-protector.sh	405 B	-rwxr-xr-x
gcc-x86_64-has-stack-protector.sh	195 B	-rwxr-xr-x
generate_initcall_order.pl	5.95 KB	-rwxr-xr-x
generate_rust_analyzer.py	5.54 KB	-rwxr-xr-x
generate_rust_target.rs	5.58 KB	-rw-r--r--
gen-randstruct-seed.sh	228 B	-rwxr-xr-x
get_abi.pl	25.36 KB	-rwxr-xr-x
get_dvb_firmware	24.54 KB	-rwxr-xr-x
get_feat.pl	14.61 KB	-rwxr-xr-x
get_maintainer.pl	67.63 KB	-rwxr-xr-x
gfp-translate	2.08 KB	-rwxr-xr-x
git.orderFile	564 B	-rw-r--r--
headerdep.pl	3.5 KB	-rwxr-xr-x
headers_install.sh	2.76 KB	-rwxr-xr-x
head-object-list.txt	1.36 KB	-rw-r--r--
insert-sys-cert	21.46 KB	-rwxr-xr-x
insert-sys-cert.c	13.08 KB	-rw-r--r--
install.sh	986 B	-rwxr-xr-x
jobserver-exec	2.56 KB	-rwxr-xr-x
kallsyms	21.63 KB	-rwxr-xr-x
kallsyms.c	17.75 KB	-rw-r--r--
Kbuild.include	10.1 KB	-rw-r--r--
Kconfig.include	2.65 KB	-rw-r--r--
kernel-doc	77.13 KB	-rwxr-xr-x
ld-version.sh	1.82 KB	-rwxr-xr-x
leaking_addresses.pl	12.84 KB	-rwxr-xr-x
Lindent	502 B	-rwxr-xr-x
link-vmlinux.sh	7.66 KB	-rwxr-xr-x
Makefile	1.87 KB	-rw-r--r--
Makefile.asm-generic	1.82 KB	-rw-r--r--
Makefile.btf	638 B	-rw-r--r--
Makefile.build	17.2 KB	-rw-r--r--
Makefile.clang	1.61 KB	-rw-r--r--
Makefile.clean	1.87 KB	-rw-r--r--
Makefile.compiler	2.74 KB	-rw-r--r--
Makefile.debug	1.12 KB	-rw-r--r--
Makefile.defconf	1.04 KB	-rw-r--r--
Makefile.dtbinst	1.03 KB	-rw-r--r--
Makefile.extrawarn	7.13 KB	-rw-r--r--
Makefile.gcc-plugins	2.59 KB	-rw-r--r--
Makefile.headersinst	2.88 KB	-rw-r--r--
Makefile.host	5.91 KB	-rw-r--r--
Makefile.kasan	2.45 KB	-rw-r--r--
Makefile.kcov	333 B	-rw-r--r--
Makefile.kcsan	1004 B	-rw-r--r--
Makefile.kmsan	208 B	-rw-r--r--
Makefile.lib	21.08 KB	-rw-r--r--
Makefile.modfinal	2.63 KB	-rw-r--r--
Makefile.modinst	4.02 KB	-rw-r--r--
Makefile.modpost	4.69 KB	-rw-r--r--
Makefile.package	8.73 KB	-rw-r--r--
Makefile.randstruct	511 B	-rw-r--r--
Makefile.ubsan	779 B	-rw-r--r--
Makefile.userprogs	1.59 KB	-rw-r--r--
Makefile.vdsoinst	1.15 KB	-rw-r--r--
Makefile.vmlinux	1.48 KB	-rw-r--r--
Makefile.vmlinux_o	3.27 KB	-rw-r--r--
makelst	808 B	-rwxr-xr-x
markup_oops.pl	7.92 KB	-rwxr-xr-x
min-tool-version.sh	630 B	-rwxr-xr-x
misc-check	509 B	-rwxr-xr-x
mkcompile_h	642 B	-rwxr-xr-x
mksysmap	2.08 KB	-rwxr-xr-x
mkuboot.sh	414 B	-rwxr-xr-x
module.lds	615 B	-rw-r--r--
module.lds.S	1.43 KB	-rw-r--r--
modules-check.sh	443 B	-rwxr-xr-x
nsdeps	1.63 KB	-rw-r--r--
objdiff	2.83 KB	-rwxr-xr-x
objdump-func	848 B	-rwxr-xr-x
orc_hash.sh	316 B	-rw-r--r--
pahole-version.sh	269 B	-rwxr-xr-x
parse-maintainers.pl	4.54 KB	-rwxr-xr-x
patch-kernel	9.95 KB	-rwxr-xr-x
profile2linkerlist.pl	414 B	-rwxr-xr-x
prune-kernel	912 B	-rwxr-xr-x
recordmcount.c	17.51 KB	-rw-r--r--
recordmcount.h	19.37 KB	-rw-r--r--
recordmcount.pl	17.34 KB	-rwxr-xr-x
relocs_check.sh	717 B	-rwxr-xr-x
remove-stale-files	1.29 KB	-rwxr-xr-x
rustdoc_test_builder.rs	3.25 KB	-rw-r--r--
rustdoc_test_gen.rs	9.48 KB	-rw-r--r--
rust_is_available_bindgen_libclang.h	91 B	-rw-r--r--
rust_is_available.sh	9.48 KB	-rwxr-xr-x
rust_is_available_test.py	17.7 KB	-rwxr-xr-x
setlocalversion	5.18 KB	-rwxr-xr-x
show_delta	3.04 KB	-rwxr-xr-x
sign-file	25.82 KB	-rwxr-xr-x
sign-file.c	9.93 KB	-rw-r--r--
sorttable	21.26 KB	-rwxr-xr-x
sorttable.c	7.68 KB	-rw-r--r--
sorttable.h	12.99 KB	-rw-r--r--
spdxcheck.py	15.23 KB	-rwxr-xr-x
spdxcheck-test.sh	284 B	-rw-r--r--
spdxexclude	417 B	-rw-r--r--
spelling.txt	34.18 KB	-rw-r--r--
sphinx-pre-install	25.07 KB	-rwxr-xr-x
split-man.pl	604 B	-rwxr-xr-x
stackdelta	1.84 KB	-rwxr-xr-x
stackusage	794 B	-rwxr-xr-x
subarch.include	647 B	-rw-r--r--
syscallhdr.sh	1.89 KB	-rwxr-xr-x
syscallnr.sh	1.45 KB	-rwxr-xr-x
syscalltbl.sh	1.82 KB	-rwxr-xr-x
tags.sh	10.73 KB	-rwxr-xr-x
test_fortify.sh	2.23 KB	-rw-r--r--
tools-support-relr.sh	726 B	-rwxr-xr-x
unifdef.c	34.8 KB	-rw-r--r--
ver_linux	2.59 KB	-rwxr-xr-x
xen-hypercalls.sh	386 B	-rwxr-xr-x
xz_wrap.sh	516 B	-rwxr-xr-x

Code Editor : rust_is_available_test.py

#!/usr/bin/env python3
# SPDX-License-Identifier: GPL-2.0

"""Tests the `rust_is_available.sh` script.

Some of the tests require the real programs to be available in `$PATH`
under their canonical name (and with the expected versions).
"""

import enum
import os
import pathlib
import stat
import subprocess
import tempfile
import unittest

class TestRustIsAvailable(unittest.TestCase):
    @enum.unique
    class Expected(enum.Enum):
        SUCCESS = enum.auto()
        SUCCESS_WITH_WARNINGS = enum.auto()
        SUCCESS_WITH_EXTRA_OUTPUT = enum.auto()
        FAILURE = enum.auto()

@classmethod
    def generate_executable(cls, content):
        path = pathlib.Path(cls.tempdir.name)
        name = str(len(tuple(path.iterdir())))
        path = path / name
        with open(path, "w") as file_:
            file_.write(content)
        os.chmod(path, os.stat(path).st_mode | stat.S_IXUSR)
        return path

@classmethod
    def generate_clang(cls, stdout):
        return cls.generate_executable(f"""#!/usr/bin/env python3
import sys
if "-E" in " ".join(sys.argv):
    print({repr("Clang " + " ".join(cls.llvm_default_version.split(" ")))})
else:
    print({repr(stdout)})
""")

@classmethod
    def generate_rustc(cls, stdout):
        return cls.generate_executable(f"""#!/usr/bin/env python3
import sys
if "--print sysroot" in " ".join(sys.argv):
    print({repr(cls.rust_default_sysroot)})
else:
    print({repr(stdout)})
""")

@classmethod
    def generate_bindgen(cls, version_stdout, libclang_stderr):
        return cls.generate_executable(f"""#!/usr/bin/env python3
import sys
if "rust_is_available_bindgen_libclang.h" in " ".join(sys.argv):
    print({repr(libclang_stderr)}, file=sys.stderr)
else:
    print({repr(version_stdout)})
""")

@classmethod
    def generate_bindgen_version(cls, stdout):
        return cls.generate_bindgen(stdout, cls.bindgen_default_bindgen_libclang_stderr)

@classmethod
    def generate_bindgen_libclang(cls, stderr):
        return cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, stderr)

@classmethod
    def setUpClass(cls):
        cls.tempdir = tempfile.TemporaryDirectory()

cls.missing = pathlib.Path(cls.tempdir.name) / "missing"

cls.nonexecutable = pathlib.Path(cls.tempdir.name) / "nonexecutable"
        with open(cls.nonexecutable, "w") as file_:
            file_.write("nonexecutable")

cls.unexpected_binary = "true"

cls.rustc_default_version = subprocess.check_output(("scripts/min-tool-version.sh", "rustc")).decode().strip()
        cls.bindgen_default_version = subprocess.check_output(("scripts/min-tool-version.sh", "bindgen")).decode().strip()
        cls.llvm_default_version = subprocess.check_output(("scripts/min-tool-version.sh", "llvm")).decode().strip()
        cls.rust_default_sysroot = subprocess.check_output(("rustc", "--print", "sysroot")).decode().strip()

cls.bindgen_default_bindgen_version_stdout = f"bindgen {cls.bindgen_default_version}"
        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"

cls.default_rustc = cls.generate_rustc(f"rustc {cls.rustc_default_version}")
        cls.default_bindgen =  cls.generate_bindgen(cls.bindgen_default_bindgen_version_stdout, cls.bindgen_default_bindgen_libclang_stderr)
        cls.default_cc = cls.generate_clang(f"clang version {cls.llvm_default_version}")

def run_script(self, expected, override_env):
        env = {
            "RUSTC": self.default_rustc,
            "BINDGEN": self.default_bindgen,
            "CC": self.default_cc,
        }

for key, value in override_env.items():
            if value is None:
                del env[key]
                continue
            env[key] = value

result = subprocess.run("scripts/rust_is_available.sh", env=env, capture_output=True)

# The script should never output anything to `stdout`.
        self.assertEqual(result.stdout, b"")

if expected == self.Expected.SUCCESS:
            # When expecting a success, the script should return 0
            # and it should not output anything to `stderr`.
            self.assertEqual(result.returncode, 0)
            self.assertEqual(result.stderr, b"")
        elif expected == self.Expected.SUCCESS_WITH_EXTRA_OUTPUT:
            # When expecting a success with extra output (that is not warnings,
            # which is the common case), the script should return 0 and it
            # should output at least something to `stderr` (the output should
            # be checked further by the test).
            self.assertEqual(result.returncode, 0)
            self.assertNotEqual(result.stderr, b"")
        elif expected == self.Expected.SUCCESS_WITH_WARNINGS:
            # When expecting a success with warnings, the script should return 0
            # and it should output at least the instructions to `stderr`.
            self.assertEqual(result.returncode, 0)
            self.assertIn(b"Please see Documentation/rust/quick-start.rst for details", result.stderr)
        else:
            # When expecting a failure, the script should return non-0
            # and it should output at least the instructions to `stderr`.
            self.assertNotEqual(result.returncode, 0)
            self.assertIn(b"Please see Documentation/rust/quick-start.rst for details", result.stderr)

# The output will generally be UTF-8 (i.e. unless the user has
        # put strange values in the environment).
        result.stderr = result.stderr.decode()

return result

def test_rustc_unset(self):
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": None })
        self.assertIn("Environment variable 'RUSTC' is not set.", result.stderr)
        self.assertIn("This script is intended to be called from Kbuild.", result.stderr)

def test_bindgen_unset(self):
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": None })
        self.assertIn("Environment variable 'BINDGEN' is not set.", result.stderr)
        self.assertIn("This script is intended to be called from Kbuild.", result.stderr)

def test_cc_unset(self):
        result = self.run_script(self.Expected.FAILURE, { "CC": None })
        self.assertIn("Environment variable 'CC' is not set.", result.stderr)
        self.assertIn("This script is intended to be called from Kbuild.", result.stderr)

def test_rustc_missing(self):
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": self.missing })
        self.assertIn(f"Rust compiler '{self.missing}' could not be found.", result.stderr)

def test_bindgen_missing(self):
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.missing })
        self.assertIn(f"Rust bindings generator '{self.missing}' could not be found.", result.stderr)

def test_rustc_nonexecutable(self):
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": self.nonexecutable })
        self.assertIn(f"Running '{self.nonexecutable}' to check the Rust compiler version failed with", result.stderr)

def test_rustc_unexpected_binary(self):
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": self.unexpected_binary })
        self.assertIn(f"Running '{self.unexpected_binary}' to check the Rust compiler version did not return", result.stderr)

def test_rustc_unexpected_name(self):
        rustc = self.generate_rustc(f"unexpected {self.rustc_default_version} (a8314ef7d 2022-06-27)")
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
        self.assertIn(f"Running '{rustc}' to check the Rust compiler version did not return", result.stderr)

def test_rustc_unexpected_version(self):
        rustc = self.generate_rustc("rustc unexpected (a8314ef7d 2022-06-27)")
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
        self.assertIn(f"Running '{rustc}' to check the Rust compiler version did not return", result.stderr)

def test_rustc_no_minor(self):
        rustc = self.generate_rustc(f"rustc {'.'.join(self.rustc_default_version.split('.')[:2])} (a8314ef7d 2022-06-27)")
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
        self.assertIn(f"Running '{rustc}' to check the Rust compiler version did not return", result.stderr)

def test_rustc_old_version(self):
        rustc = self.generate_rustc("rustc 1.60.0 (a8314ef7d 2022-06-27)")
        result = self.run_script(self.Expected.FAILURE, { "RUSTC": rustc })
        self.assertIn(f"Rust compiler '{rustc}' is too old.", result.stderr)

def test_rustc_new_version(self):
        rustc = self.generate_rustc("rustc 1.999.0 (a8314ef7d 2099-06-27)")
        result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "RUSTC": rustc })
        self.assertIn(f"Rust compiler '{rustc}' is too new. This may or may not work.", result.stderr)

def test_bindgen_nonexecutable(self):
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.nonexecutable })
        self.assertIn(f"Running '{self.nonexecutable}' to check the Rust bindings generator version failed with", result.stderr)

def test_bindgen_unexpected_binary(self):
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": self.unexpected_binary })
        self.assertIn(f"Running '{self.unexpected_binary}' to check the bindings generator version did not return", result.stderr)

def test_bindgen_unexpected_name(self):
        bindgen = self.generate_bindgen_version(f"unexpected {self.bindgen_default_version}")
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
        self.assertIn(f"Running '{bindgen}' to check the bindings generator version did not return", result.stderr)

def test_bindgen_unexpected_version(self):
        bindgen = self.generate_bindgen_version("bindgen unexpected")
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
        self.assertIn(f"Running '{bindgen}' to check the bindings generator version did not return", result.stderr)

def test_bindgen_no_minor(self):
        bindgen = self.generate_bindgen_version(f"bindgen {'.'.join(self.bindgen_default_version.split('.')[:2])}")
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
        self.assertIn(f"Running '{bindgen}' to check the bindings generator version did not return", result.stderr)

def test_bindgen_old_version(self):
        bindgen = self.generate_bindgen_version("bindgen 0.50.0")
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
        self.assertIn(f"Rust bindings generator '{bindgen}' is too old.", result.stderr)

def test_bindgen_new_version(self):
        bindgen = self.generate_bindgen_version("bindgen 0.999.0")
        result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen })
        self.assertIn(f"Rust bindings generator '{bindgen}' is too new. This may or may not work.", result.stderr)

def test_bindgen_libclang_failure(self):
        for env in (
            { "LLVM_CONFIG_PATH": self.missing },
            { "LIBCLANG_PATH": self.missing },
            { "CLANG_PATH": self.missing },
        ):
            with self.subTest(env=env):
                result = self.run_script(self.Expected.FAILURE, env | { "PATH": os.environ["PATH"], "BINDGEN": "bindgen" })
                self.assertIn("Running 'bindgen' to check the libclang version (used by the Rust", result.stderr)
                self.assertIn("bindings generator) failed with code ", result.stderr)

def test_bindgen_libclang_unexpected_version(self):
        bindgen = self.generate_bindgen_libclang("scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version unexpected [-W#pragma-messages], err: false")
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
        self.assertIn(f"Running '{bindgen}' to check the libclang version (used by the Rust", result.stderr)
        self.assertIn("bindings generator) did not return an expected output. See output", result.stderr)

def test_bindgen_libclang_old_version(self):
        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")
        result = self.run_script(self.Expected.FAILURE, { "BINDGEN": bindgen })
        self.assertIn(f"libclang (used by the Rust bindings generator '{bindgen}') is too old.", result.stderr)

def test_clang_matches_bindgen_libclang_different_bindgen(self):
        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")
        result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "BINDGEN": bindgen })
        self.assertIn("version does not match Clang's. This may be a problem.", result.stderr)

def test_clang_matches_bindgen_libclang_different_clang(self):
        cc = self.generate_clang("clang version 999.0.0")
        result = self.run_script(self.Expected.SUCCESS_WITH_WARNINGS, { "CC": cc })
        self.assertIn("version does not match Clang's. This may be a problem.", result.stderr)

def test_rustc_src_core_krustflags(self):
        result = self.run_script(self.Expected.FAILURE, { "PATH": os.environ["PATH"], "RUSTC": "rustc", "KRUSTFLAGS": f"--sysroot={self.missing}" })
        self.assertIn("Source code for the 'core' standard library could not be found", result.stderr)

def test_rustc_src_core_rustlibsrc(self):
        result = self.run_script(self.Expected.FAILURE, { "RUST_LIB_SRC": self.missing })
        self.assertIn("Source code for the 'core' standard library could not be found", result.stderr)

def test_success_cc_unknown(self):
        result = self.run_script(self.Expected.SUCCESS_WITH_EXTRA_OUTPUT, { "CC": self.missing })
        self.assertIn("unknown C compiler", result.stderr)

def test_success_cc_multiple_arguments_ccache(self):
        clang = self.generate_clang(f"""Ubuntu clang version {self.llvm_default_version}-1ubuntu1
Target: x86_64-pc-linux-gnu
Thread model: posix
InstalledDir: /usr/bin
""")
        result = self.run_script(self.Expected.SUCCESS, { "CC": f"{clang} clang" })

def test_success_rustc_version(self):
        for rustc_stdout in (
            f"rustc {self.rustc_default_version} (a8314ef7d 2022-06-27)",
            f"rustc {self.rustc_default_version}-dev (a8314ef7d 2022-06-27)",
            f"rustc {self.rustc_default_version}-1.60.0 (a8314ef7d 2022-06-27)",
        ):
            with self.subTest(rustc_stdout=rustc_stdout):
                rustc = self.generate_rustc(rustc_stdout)
                result = self.run_script(self.Expected.SUCCESS, { "RUSTC": rustc })

def test_success_bindgen_version(self):
        for bindgen_stdout in (
            f"bindgen {self.bindgen_default_version}",
            f"bindgen {self.bindgen_default_version}-dev",
            f"bindgen {self.bindgen_default_version}-0.999.0",
        ):
            with self.subTest(bindgen_stdout=bindgen_stdout):
                bindgen = self.generate_bindgen_version(bindgen_stdout)
                result = self.run_script(self.Expected.SUCCESS, { "BINDGEN": bindgen })

def test_success_bindgen_libclang(self):
        for stderr in (
            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",
            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",
            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",
            f"""
/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1-p16/bin/bash: warning: setlocale: LC_ALL: cannot change locale (c)
scripts/rust_is_available_bindgen_libclang.h:2:9: warning: clang version {self.llvm_default_version}  [-W#pragma-messages], err: false
""",
            f"""
/nix/store/dsd5gz46hdbdk2rfdimqddhq6m8m8fqs-bash-5.1.0-p16/bin/bash: warning: setlocale: LC_ALL: cannot change locale (c)
/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
"""
        ):
            with self.subTest(stderr=stderr):
                bindgen = self.generate_bindgen_libclang(stderr)
                result = self.run_script(self.Expected.SUCCESS, { "BINDGEN": bindgen })

def test_success_clang_version(self):
        for clang_stdout in (
            f"clang version {self.llvm_default_version} (https://github.com/llvm/llvm-project.git 4a2c05b05ed07f1f620e94f6524a8b4b2760a0b1)",
            f"clang version {self.llvm_default_version}-dev",
            f"clang version {self.llvm_default_version}-2~ubuntu20.04.1",
            f"Ubuntu clang version {self.llvm_default_version}-2~ubuntu20.04.1",
        ):
            with self.subTest(clang_stdout=clang_stdout):
                clang = self.generate_clang(clang_stdout)
                result = self.run_script(self.Expected.SUCCESS, { "CC": clang })

def test_success_real_programs(self):
        for cc in ["gcc", "clang"]:
            with self.subTest(cc=cc):
                result = self.run_script(self.Expected.SUCCESS, {
                    "PATH": os.environ["PATH"],
                    "RUSTC": "rustc",
                    "BINDGEN": "bindgen",
                    "CC": cc,
                })

if __name__ == "__main__":
    unittest.main()

${this.title}

Code Editor : rust_is_available_test.py