1 use super::{make_test, TestOptions};
2 use rustc_span::edition::DEFAULT_EDITION;
6 //basic use: wraps with `fn main`, adds `#![allow(unused)]`
7 let opts = TestOptions::default();
8 let input = "assert_eq!(2+2, 4);";
9 let expected = "#![allow(unused)]
14 let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
15 assert_eq!((output, len), (expected, 2));
19 fn make_test_crate_name_no_use() {
20 // If you give a crate name but *don't* use it within the test, it won't bother inserting
21 // the `extern crate` statement.
22 let opts = TestOptions::default();
23 let input = "assert_eq!(2+2, 4);";
24 let expected = "#![allow(unused)]
29 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
30 assert_eq!((output, len), (expected, 2));
34 fn make_test_crate_name() {
35 // If you give a crate name and use it within the test, it will insert an `extern crate`
36 // statement before `fn main`.
37 let opts = TestOptions::default();
38 let input = "use asdf::qwop;
40 let expected = "#![allow(unused)]
47 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
48 assert_eq!((output, len), (expected, 3));
52 fn make_test_no_crate_inject() {
53 // Even if you do use the crate within the test, setting `opts.no_crate_inject` will skip
55 let opts = TestOptions { no_crate_inject: true, attrs: vec![] };
56 let input = "use asdf::qwop;
58 let expected = "#![allow(unused)]
64 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
65 assert_eq!((output, len), (expected, 2));
69 fn make_test_ignore_std() {
70 // Even if you include a crate name, and use it in the doctest, we still won't include an
71 // `extern crate` statement if the crate is "std" -- that's included already by the
73 let opts = TestOptions::default();
74 let input = "use std::*;
76 let expected = "#![allow(unused)]
82 let (output, len, _) = make_test(input, Some("std"), false, &opts, DEFAULT_EDITION, None);
83 assert_eq!((output, len), (expected, 2));
87 fn make_test_manual_extern_crate() {
88 // When you manually include an `extern crate` statement in your doctest, `make_test`
89 // assumes you've included one for your own crate too.
90 let opts = TestOptions::default();
91 let input = "extern crate asdf;
94 let expected = "#![allow(unused)]
101 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
102 assert_eq!((output, len), (expected, 2));
106 fn make_test_manual_extern_crate_with_macro_use() {
107 let opts = TestOptions::default();
108 let input = "#[macro_use] extern crate asdf;
110 assert_eq!(2+2, 4);";
111 let expected = "#![allow(unused)]
112 #[macro_use] extern crate asdf;
118 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
119 assert_eq!((output, len), (expected, 2));
123 fn make_test_opts_attrs() {
124 // If you supplied some doctest attributes with `#![doc(test(attr(...)))]`, it will use
125 // those instead of the stock `#![allow(unused)]`.
126 let mut opts = TestOptions::default();
127 opts.attrs.push("feature(sick_rad)".to_string());
128 let input = "use asdf::qwop;
129 assert_eq!(2+2, 4);";
130 let expected = "#![feature(sick_rad)]
137 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
138 assert_eq!((output, len), (expected, 3));
140 // Adding more will also bump the returned line offset.
141 opts.attrs.push("feature(hella_dope)".to_string());
142 let expected = "#![feature(sick_rad)]
143 #![feature(hella_dope)]
150 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
151 assert_eq!((output, len), (expected, 4));
155 fn make_test_crate_attrs() {
156 // Including inner attributes in your doctest will apply them to the whole "crate", pasting
157 // them outside the generated main function.
158 let opts = TestOptions::default();
159 let input = "#![feature(sick_rad)]
160 assert_eq!(2+2, 4);";
161 let expected = "#![allow(unused)]
162 #![feature(sick_rad)]
167 let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
168 assert_eq!((output, len), (expected, 2));
172 fn make_test_with_main() {
173 // Including your own `fn main` wrapper lets the test use it verbatim.
174 let opts = TestOptions::default();
175 let input = "fn main() {
178 let expected = "#![allow(unused)]
183 let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
184 assert_eq!((output, len), (expected, 1));
188 fn make_test_fake_main() {
189 // ... but putting it in a comment will still provide a wrapper.
190 let opts = TestOptions::default();
191 let input = "//Ceci n'est pas une `fn main`
192 assert_eq!(2+2, 4);";
193 let expected = "#![allow(unused)]
194 //Ceci n'est pas une `fn main`
199 let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
200 assert_eq!((output, len), (expected, 2));
204 fn make_test_dont_insert_main() {
205 // Even with that, if you set `dont_insert_main`, it won't create the `fn main` wrapper.
206 let opts = TestOptions::default();
207 let input = "//Ceci n'est pas une `fn main`
208 assert_eq!(2+2, 4);";
209 let expected = "#![allow(unused)]
210 //Ceci n'est pas une `fn main`
213 let (output, len, _) = make_test(input, None, true, &opts, DEFAULT_EDITION, None);
214 assert_eq!((output, len), (expected, 1));
218 fn make_test_issues_21299_33731() {
219 let opts = TestOptions::default();
221 let input = "// fn main
222 assert_eq!(2+2, 4);";
224 let expected = "#![allow(unused)]
231 let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
232 assert_eq!((output, len), (expected, 2));
234 let input = "extern crate hella_qwop;
235 assert_eq!(asdf::foo, 4);";
237 let expected = "#![allow(unused)]
238 extern crate hella_qwop;
241 assert_eq!(asdf::foo, 4);
245 let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
246 assert_eq!((output, len), (expected, 3));
250 fn make_test_main_in_macro() {
251 let opts = TestOptions::default();
252 let input = "#[macro_use] extern crate my_crate;
256 let expected = "#![allow(unused)]
257 #[macro_use] extern crate my_crate;
263 let (output, len, _) = make_test(input, Some("my_crate"), false, &opts, DEFAULT_EDITION, None);
264 assert_eq!((output, len), (expected, 1));
268 fn make_test_returns_result() {
269 // creates an inner function and unwraps it
270 let opts = TestOptions::default();
271 let input = "use std::io;
272 let mut input = String::new();
273 io::stdin().read_line(&mut input)?;
274 Ok::<(), io:Error>(())";
275 let expected = "#![allow(unused)]
276 fn main() { fn _inner() -> Result<(), impl core::fmt::Debug> {
278 let mut input = String::new();
279 io::stdin().read_line(&mut input)?;
280 Ok::<(), io:Error>(())
281 } _inner().unwrap() }"
283 let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
284 assert_eq!((output, len), (expected, 2));
288 fn make_test_named_wrapper() {
289 // creates an inner function with a specific name
290 let opts = TestOptions::default();
291 let input = "assert_eq!(2+2, 4);";
292 let expected = "#![allow(unused)]
293 fn main() { #[allow(non_snake_case)] fn _doctest_main__some_unique_name() {
295 } _doctest_main__some_unique_name() }"
297 let (output, len, _) =
298 make_test(input, None, false, &opts, DEFAULT_EDITION, Some("_some_unique_name"));
299 assert_eq!((output, len), (expected, 2));