src/librustdoc/doctest/tests.rs

   1 use super::{make_test, GlobalTestOptions};
   2 use rustc_span::edition::DEFAULT_EDITION;
   3
   4 #[test]
   5 fn make_test_basic() {
   6     //basic use: wraps with `fn main`, adds `#![allow(unused)]`
   7     let opts = GlobalTestOptions::default();
   8     let input = "assert_eq!(2+2, 4);";
   9     let expected = "#![allow(unused)]
  10 fn main() {
  11 assert_eq!(2+2, 4);
  12 }"
  13     .to_string();
  14     let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
  15     assert_eq!((output, len), (expected, 2));
  16 }
  17
  18 #[test]
  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 = GlobalTestOptions::default();
  23     let input = "assert_eq!(2+2, 4);";
  24     let expected = "#![allow(unused)]
  25 fn main() {
  26 assert_eq!(2+2, 4);
  27 }"
  28     .to_string();
  29     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
  30     assert_eq!((output, len), (expected, 2));
  31 }
  32
  33 #[test]
  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 = GlobalTestOptions::default();
  38     let input = "use asdf::qwop;
  39 assert_eq!(2+2, 4);";
  40     let expected = "#![allow(unused)]
  41 extern crate r#asdf;
  42 fn main() {
  43 use asdf::qwop;
  44 assert_eq!(2+2, 4);
  45 }"
  46     .to_string();
  47     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
  48     assert_eq!((output, len), (expected, 3));
  49 }
  50
  51 #[test]
  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
  54     // adding it anyway.
  55     let opts = GlobalTestOptions { no_crate_inject: true, attrs: vec![] };
  56     let input = "use asdf::qwop;
  57 assert_eq!(2+2, 4);";
  58     let expected = "#![allow(unused)]
  59 fn main() {
  60 use asdf::qwop;
  61 assert_eq!(2+2, 4);
  62 }"
  63     .to_string();
  64     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
  65     assert_eq!((output, len), (expected, 2));
  66 }
  67
  68 #[test]
  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
  72     // compiler!
  73     let opts = GlobalTestOptions::default();
  74     let input = "use std::*;
  75 assert_eq!(2+2, 4);";
  76     let expected = "#![allow(unused)]
  77 fn main() {
  78 use std::*;
  79 assert_eq!(2+2, 4);
  80 }"
  81     .to_string();
  82     let (output, len, _) = make_test(input, Some("std"), false, &opts, DEFAULT_EDITION, None);
  83     assert_eq!((output, len), (expected, 2));
  84 }
  85
  86 #[test]
  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 = GlobalTestOptions::default();
  91     let input = "extern crate asdf;
  92 use asdf::qwop;
  93 assert_eq!(2+2, 4);";
  94     let expected = "#![allow(unused)]
  95 extern crate asdf;
  96 fn main() {
  97 use asdf::qwop;
  98 assert_eq!(2+2, 4);
  99 }"
 100     .to_string();
 101     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
 102     assert_eq!((output, len), (expected, 2));
 103 }
 104
 105 #[test]
 106 fn make_test_manual_extern_crate_with_macro_use() {
 107     let opts = GlobalTestOptions::default();
 108     let input = "#[macro_use] extern crate asdf;
 109 use asdf::qwop;
 110 assert_eq!(2+2, 4);";
 111     let expected = "#![allow(unused)]
 112 #[macro_use] extern crate asdf;
 113 fn main() {
 114 use asdf::qwop;
 115 assert_eq!(2+2, 4);
 116 }"
 117     .to_string();
 118     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
 119     assert_eq!((output, len), (expected, 2));
 120 }
 121
 122 #[test]
 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 = GlobalTestOptions::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)]
 131 extern crate r#asdf;
 132 fn main() {
 133 use asdf::qwop;
 134 assert_eq!(2+2, 4);
 135 }"
 136     .to_string();
 137     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
 138     assert_eq!((output, len), (expected, 3));
 139
 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)]
 144 extern crate r#asdf;
 145 fn main() {
 146 use asdf::qwop;
 147 assert_eq!(2+2, 4);
 148 }"
 149     .to_string();
 150     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
 151     assert_eq!((output, len), (expected, 4));
 152 }
 153
 154 #[test]
 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 = GlobalTestOptions::default();
 159     let input = "#![feature(sick_rad)]
 160 assert_eq!(2+2, 4);";
 161     let expected = "#![allow(unused)]
 162 #![feature(sick_rad)]
 163 fn main() {
 164 assert_eq!(2+2, 4);
 165 }"
 166     .to_string();
 167     let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
 168     assert_eq!((output, len), (expected, 2));
 169 }
 170
 171 #[test]
 172 fn make_test_with_main() {
 173     // Including your own `fn main` wrapper lets the test use it verbatim.
 174     let opts = GlobalTestOptions::default();
 175     let input = "fn main() {
 176     assert_eq!(2+2, 4);
 177 }";
 178     let expected = "#![allow(unused)]
 179 fn main() {
 180     assert_eq!(2+2, 4);
 181 }"
 182     .to_string();
 183     let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
 184     assert_eq!((output, len), (expected, 1));
 185 }
 186
 187 #[test]
 188 fn make_test_fake_main() {
 189     // ... but putting it in a comment will still provide a wrapper.
 190     let opts = GlobalTestOptions::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`
 195 fn main() {
 196 assert_eq!(2+2, 4);
 197 }"
 198     .to_string();
 199     let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
 200     assert_eq!((output, len), (expected, 2));
 201 }
 202
 203 #[test]
 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 = GlobalTestOptions::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`
 211 assert_eq!(2+2, 4);"
 212         .to_string();
 213     let (output, len, _) = make_test(input, None, true, &opts, DEFAULT_EDITION, None);
 214     assert_eq!((output, len), (expected, 1));
 215 }
 216
 217 #[test]
 218 fn make_test_issues_21299_33731() {
 219     let opts = GlobalTestOptions::default();
 220
 221     let input = "// fn main
 222 assert_eq!(2+2, 4);";
 223
 224     let expected = "#![allow(unused)]
 225 // fn main
 226 fn main() {
 227 assert_eq!(2+2, 4);
 228 }"
 229     .to_string();
 230
 231     let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
 232     assert_eq!((output, len), (expected, 2));
 233
 234     let input = "extern crate hella_qwop;
 235 assert_eq!(asdf::foo, 4);";
 236
 237     let expected = "#![allow(unused)]
 238 extern crate hella_qwop;
 239 extern crate r#asdf;
 240 fn main() {
 241 assert_eq!(asdf::foo, 4);
 242 }"
 243     .to_string();
 244
 245     let (output, len, _) = make_test(input, Some("asdf"), false, &opts, DEFAULT_EDITION, None);
 246     assert_eq!((output, len), (expected, 3));
 247 }
 248
 249 #[test]
 250 fn make_test_main_in_macro() {
 251     let opts = GlobalTestOptions::default();
 252     let input = "#[macro_use] extern crate my_crate;
 253 test_wrapper! {
 254     fn main() {}
 255 }";
 256     let expected = "#![allow(unused)]
 257 #[macro_use] extern crate my_crate;
 258 test_wrapper! {
 259     fn main() {}
 260 }"
 261     .to_string();
 262
 263     let (output, len, _) = make_test(input, Some("my_crate"), false, &opts, DEFAULT_EDITION, None);
 264     assert_eq!((output, len), (expected, 1));
 265 }
 266
 267 #[test]
 268 fn make_test_returns_result() {
 269     // creates an inner function and unwraps it
 270     let opts = GlobalTestOptions::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> {
 277 use std::io;
 278 let mut input = String::new();
 279 io::stdin().read_line(&mut input)?;
 280 Ok::<(), io:Error>(())
 281 } _inner().unwrap() }"
 282         .to_string();
 283     let (output, len, _) = make_test(input, None, false, &opts, DEFAULT_EDITION, None);
 284     assert_eq!((output, len), (expected, 2));
 285 }
 286
 287 #[test]
 288 fn make_test_named_wrapper() {
 289     // creates an inner function with a specific name
 290     let opts = GlobalTestOptions::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() {
 294 assert_eq!(2+2, 4);
 295 } _doctest_main__some_unique_name() }"
 296         .to_string();
 297     let (output, len, _) =
 298         make_test(input, None, false, &opts, DEFAULT_EDITION, Some("_some_unique_name"));
 299     assert_eq!((output, len), (expected, 2));
 300 }