1 // SPDX-License-Identifier: GPL-2.0 2 3 //! Test builder for `rustdoc`-generated tests. 4 //! 5 //! This script is a hack to extract the test from `rustdoc`'s output. Ideally, `rustdoc` would 6 //! have an option to generate this information instead, e.g. as JSON output. 7 //! 8 //! The `rustdoc`-generated test names look like `{file}_{line}_{number}`, e.g. 9 //! `...path_rust_kernel_sync_arc_rs_42_0`. `number` is the "test number", needed in cases like 10 //! a macro that expands into items with doctests is invoked several times within the same line. 11 //! 12 //! However, since these names are used for bisection in CI, the line number makes it not stable 13 //! at all. In the future, we would like `rustdoc` to give us the Rust item path associated with 14 //! the test, plus a "test number" (for cases with several examples per item) and generate a name 15 //! from that. For the moment, we generate ourselves a new name, `{file}_{number}` instead, in 16 //! the `gen` script (done there since we need to be aware of all the tests in a given file). 17 18 use std::io::Read; 19 20 fn main() { 21 let mut stdin = std::io::stdin().lock(); 22 let mut body = String::new(); 23 stdin.read_to_string(&mut body).unwrap(); 24 25 // Find the generated function name looking for the inner function inside `main()`. 26 // 27 // The line we are looking for looks like one of the following: 28 // 29 // ``` 30 // fn main() { #[allow(non_snake_case)] fn _doctest_main_rust_kernel_file_rs_28_0() { 31 // fn main() { #[allow(non_snake_case)] fn _doctest_main_rust_kernel_file_rs_37_0() -> Result<(), impl core::fmt::Debug> { 32 // ``` 33 // 34 // It should be unlikely that doctest code matches such lines (when code is formatted properly). 35 let rustdoc_function_name = body 36 .lines() 37 .find_map(|line| { 38 Some( 39 line.split_once("fn main() {")? 40 .1 41 .split_once("fn ")? 42 .1 43 .split_once("()")? 44 .0, 45 ) 46 .filter(|x| x.chars().all(|c| c.is_alphanumeric() || c == '_')) 47 }) 48 .expect("No test function found in `rustdoc`'s output."); 49 50 // Qualify `Result` to avoid the collision with our own `Result` coming from the prelude. 51 let body = body.replace( 52 &format!("{rustdoc_function_name}() -> Result<(), impl core::fmt::Debug> {{"), 53 &format!("{rustdoc_function_name}() -> core::result::Result<(), impl core::fmt::Debug> {{"), 54 ); 55 56 // For tests that get generated with `Result`, like above, `rustdoc` generates an `unwrap()` on 57 // the return value to check there were no returned errors. Instead, we use our assert macro 58 // since we want to just fail the test, not panic the kernel. 59 // 60 // We save the result in a variable so that the failed assertion message looks nicer. 61 let body = body.replace( 62 &format!("}} {rustdoc_function_name}().unwrap() }}"), 63 &format!("}} let test_return_value = {rustdoc_function_name}(); assert!(test_return_value.is_ok()); }}"), 64 ); 65 66 // Figure out a smaller test name based on the generated function name. 67 let name = rustdoc_function_name.split_once("_rust_kernel_").unwrap().1; 68 69 let path = format!("rust/test/doctests/kernel/{name}"); 70 71 std::fs::write(path, body.as_bytes()).unwrap(); 72 } 73