src/doc/rustdoc/src/documentation-tests.md

   1 # Documentation tests
   2
   3 `rustdoc` supports executing your documentation examples as tests. This makes sure
   4 that your tests are up to date and working.
   5
   6 The basic idea is this:
   7
   8 ```ignore
   9 /// # Examples
  10 ///
  11 /// ```
  12 /// let x = 5;
  13 /// ```
  14 ```
  15
  16 The triple backticks start and end code blocks. If this were in a file named `foo.rs`,
  17 running `rustdoc --test foo.rs` will extract this example, and then run it as a test.
  18
  19 Please note that by default, if no language is set for the block code, `rustdoc`
  20 assumes it is `Rust` code. So the following:
  21
  22 ``````markdown
  23 ```rust
  24 let x = 5;
  25 ```
  26 ``````
  27
  28 is strictly equivalent to:
  29
  30 ``````markdown
  31 ```
  32 let x = 5;
  33 ```
  34 ``````
  35
  36 There's some subtlety though! Read on for more details.
  37
  38 ## Passing or failing a doctest
  39
  40 Like regular unit tests, regular doctests are considered to "pass"
  41 if they compile and run without panicking.
  42 So if you want to demonstrate that some computation gives a certain result,
  43 the `assert!` family of macros works the same as other Rust code:
  44
  45 ```rust
  46 let foo = "foo";
  47
  48 assert_eq!(foo, "foo");
  49 ```
  50
  51 This way, if the computation ever returns something different,
  52 the code panics and the doctest fails.
  53
  54 ## Pre-processing examples
  55
  56 In the example above, you'll note something strange: there's no `main`
  57 function! Forcing you to write `main` for every example, no matter how small,
  58 adds friction. So `rustdoc` processes your examples slightly before
  59 running them. Here's the full algorithm rustdoc uses to preprocess examples:
  60
  61 1. Some common `allow` attributes are inserted, including
  62    `unused_variables`, `unused_assignments`, `unused_mut`,
  63    `unused_attributes`, and `dead_code`. Small examples often trigger
  64    these lints.
  65 2. Any attributes specified with `#![doc(test(attr(...)))]` are added.
  66 3. Any leading `#![foo]` attributes are left intact as crate attributes.
  67 4. If the example does not contain `extern crate`, and
  68    `#![doc(test(no_crate_inject))]` was not specified, then `extern crate
  69    <mycrate>;` is inserted (note the lack of `#[macro_use]`).
  70 5. Finally, if the example does not contain `fn main`, the remainder of the
  71    text is wrapped in `fn main() { your_code }`.
  72
  73 For more about that caveat in rule 4, see "Documenting Macros" below.
  74
  75 ## Hiding portions of the example
  76
  77 Sometimes, you need some setup code, or other things that would distract
  78 from your example, but are important to make the tests work. Consider
  79 an example block that looks like this:
  80
  81 ```text
  82 /// /// Some documentation.
  83 /// # fn foo() {} // this function will be hidden
  84 /// println!("Hello, World!");
  85 ```
  86
  87 It will render like this:
  88
  89 ```rust
  90 /// Some documentation.
  91 # fn foo() {}
  92 println!("Hello, World!");
  93 ```
  94
  95 Yes, that's right: you can add lines that start with `# `, and they will
  96 be hidden from the output, but will be used when compiling your code. You
  97 can use this to your advantage. In this case, documentation comments need
  98 to apply to some kind of function, so if I want to show you just a
  99 documentation comment, I need to add a little function definition below
 100 it. At the same time, it's only there to satisfy the compiler, so hiding
 101 it makes the example more clear. You can use this technique to explain
 102 longer examples in detail, while still preserving the testability of your
 103 documentation.
 104
 105 For example, imagine that we wanted to document this code:
 106
 107 ```rust
 108 let x = 5;
 109 let y = 6;
 110 println!("{}", x + y);
 111 ```
 112
 113 We might want the documentation to end up looking like this:
 114
 115 > First, we set `x` to five:
 116 >
 117 > ```rust
 118 > let x = 5;
 119 > # let y = 6;
 120 > # println!("{}", x + y);
 121 > ```
 122 >
 123 > Next, we set `y` to six:
 124 >
 125 > ```rust
 126 > # let x = 5;
 127 > let y = 6;
 128 > # println!("{}", x + y);
 129 > ```
 130 >
 131 > Finally, we print the sum of `x` and `y`:
 132 >
 133 > ```rust
 134 > # let x = 5;
 135 > # let y = 6;
 136 > println!("{}", x + y);
 137 > ```
 138
 139 To keep each code block testable, we want the whole program in each block, but
 140 we don't want the reader to see every line every time.  Here's what we put in
 141 our source code:
 142
 143 ``````markdown
 144 First, we set `x` to five:
 145
 146 ```
 147 let x = 5;
 148 # let y = 6;
 149 # println!("{}", x + y);
 150 ```
 151
 152 Next, we set `y` to six:
 153
 154 ```
 155 # let x = 5;
 156 let y = 6;
 157 # println!("{}", x + y);
 158 ```
 159
 160 Finally, we print the sum of `x` and `y`:
 161
 162 ```
 163 # let x = 5;
 164 # let y = 6;
 165 println!("{}", x + y);
 166 ```
 167 ``````
 168
 169 By repeating all parts of the example, you can ensure that your example still
 170 compiles, while only showing the parts that are relevant to that part of your
 171 explanation.
 172
 173
 174 ## Using `?` in doc tests
 175
 176 When writing an example, it is rarely useful to include a complete error
 177 handling, as it would add significant amounts of boilerplate code. Instead, you
 178 may want the following:
 179
 180 ```ignore
 181 /// ```
 182 /// use std::io;
 183 /// let mut input = String::new();
 184 /// io::stdin().read_line(&mut input)?;
 185 /// ```
 186 ```
 187
 188 The problem is that `?` returns a `Result<T, E>` and test functions don't
 189 return anything, so this will give a mismatched types error.
 190
 191 You can get around this limitation by manually adding a `main` that returns
 192 `Result<T, E>`, because `Result<T, E>` implements the `Termination` trait:
 193
 194 ```ignore
 195 /// A doc test using ?
 196 ///
 197 /// ```
 198 /// use std::io;
 199 ///
 200 /// fn main() -> io::Result<()> {
 201 ///     let mut input = String::new();
 202 ///     io::stdin().read_line(&mut input)?;
 203 ///     Ok(())
 204 /// }
 205 /// ```
 206 ```
 207
 208 Together with the `# ` from the section above, you arrive at a solution that
 209 appears to the reader as the initial idea but works with doc tests:
 210
 211 ```ignore
 212 /// ```
 213 /// use std::io;
 214 /// # fn main() -> io::Result<()> {
 215 /// let mut input = String::new();
 216 /// io::stdin().read_line(&mut input)?;
 217 /// # Ok(())
 218 /// # }
 219 /// ```
 220 ```
 221
 222 ## Documenting macros
 223
 224 Here’s an example of documenting a macro:
 225
 226 ```rust
 227 /// Panic with a given message unless an expression evaluates to true.
 228 ///
 229 /// # Examples
 230 ///
 231 /// ```
 232 /// # #[macro_use] extern crate foo;
 233 /// # fn main() {
 234 /// panic_unless!(1 + 1 == 2, “Math is broken.”);
 235 /// # }
 236 /// ```
 237 ///
 238 /// ```should_panic
 239 /// # #[macro_use] extern crate foo;
 240 /// # fn main() {
 241 /// panic_unless!(true == false, “I’m broken.”);
 242 /// # }
 243 /// ```
 244 #[macro_export]
 245 macro_rules! panic_unless {
 246     ($condition:expr, $($rest:expr),+) => ({ if ! $condition { panic!($($rest),+); } });
 247 }
 248 # fn main() {}
 249 ```
 250
 251 You’ll note three things: we need to add our own `extern crate` line, so that
 252 we can add the `#[macro_use]` attribute. Second, we’ll need to add our own
 253 `main()` as well (for reasons discussed above). Finally, a judicious use of
 254 `#` to comment out those two things, so they don’t show up in the output.
 255
 256 ## Attributes
 257
 258 There are a few annotations that are useful to help `rustdoc` do the right
 259 thing when testing your code:
 260
 261 ```rust
 262 /// ```ignore
 263 /// fn foo() {
 264 /// ```
 265 # fn foo() {}
 266 ```
 267
 268 The `ignore` directive tells Rust to ignore your code. This is almost never
 269 what you want, as it's the most generic. Instead, consider annotating it
 270 with `text` if it's not code, or using `#`s to get a working example that
 271 only shows the part you care about.
 272
 273 ```rust
 274 /// ```should_panic
 275 /// assert!(false);
 276 /// ```
 277 # fn foo() {}
 278 ```
 279
 280 `should_panic` tells `rustdoc` that the code should compile correctly, but
 281 not actually pass as a test.
 282
 283 ```text
 284 /// ```no_run
 285 /// loop {
 286 ///     println!("Hello, world");
 287 /// }
 288 /// ```
 289 # fn foo() {}
 290 ```
 291
 292 The `no_run` attribute will compile your code, but not run it. This is
 293 important for examples such as "Here's how to retrieve a web page,"
 294 which you would want to ensure compiles, but might be run in a test
 295 environment that has no network access.
 296
 297 ```text
 298 /// ```compile_fail
 299 /// let x = 5;
 300 /// x += 2; // shouldn't compile!
 301 /// ```
 302 ```
 303
 304 `compile_fail` tells `rustdoc` that the compilation should fail. If it
 305 compiles, then the test will fail. However please note that code failing
 306 with the current Rust release may work in a future release, as new features
 307 are added.