20| |//!
21| |//! doctest returning a result:
22| 1|//! ```
- 23| 1|//! #[derive(Debug)]
- 24| 1|//! struct SomeError;
- 25| 1|//! let mut res = Err(SomeError);
- 26| 1|//! if res.is_ok() {
- 27| 0|//! res?;
- 28| 1|//! } else {
- 29| 1|//! res = Ok(0);
- 30| 1|//! }
- 31| |//! // need to be explicit because rustdoc cant infer the return type
- 32| 1|//! Ok::<(), SomeError>(())
- 33| 1|//! ```
- 34| |//!
- 35| |//! doctest with custom main:
- 36| |//! ```
- 37| |//! #[derive(Debug)]
- 38| |//! struct SomeError;
- 39| |//!
- 40| |//! extern crate doctest_crate;
- 41| |//!
- 42| 1|//! fn doctest_main() -> Result<(), SomeError> {
- 43| 1|//! doctest_crate::fn_run_in_doctests(2);
- 44| 1|//! Ok(())
- 45| 1|//! }
- 46| |//!
- 47| |//! // this `main` is not shown as covered, as it clashes with all the other
- 48| |//! // `main` functions that were automatically generated for doctests
- 49| |//! fn main() -> Result<(), SomeError> {
- 50| |//! doctest_main()
- 51| |//! }
- 52| |//! ```
- 53| |
- 54| |/// doctest attached to fn testing external code:
- 55| |/// ```
- 56| 1|/// extern crate doctest_crate;
- 57| 1|/// doctest_crate::fn_run_in_doctests(3);
- 58| 1|/// ```
- 59| |///
- 60| 1|fn main() {
- 61| 1| if true {
- 62| 1| assert_eq!(1, 1);
- 63| | } else {
- 64| | assert_eq!(1, 2);
- 65| | }
- 66| 1|}
+ 23| 2|//! #[derive(Debug, PartialEq)]
+ ^1
+ 24| 1|//! struct SomeError {
+ 25| 1|//! msg: String,
+ 26| 1|//! }
+ 27| 1|//! let mut res = Err(SomeError { msg: String::from("a message") });
+ 28| 1|//! if res.is_ok() {
+ 29| 0|//! res?;
+ 30| |//! } else {
+ 31| 1|//! if *res.as_ref().unwrap_err() == *res.as_ref().unwrap_err() {
+ 32| 1|//! println!("{:?}", res);
+ 33| 1|//! }
+ ^0
+ 34| 1|//! if *res.as_ref().unwrap_err() == *res.as_ref().unwrap_err() {
+ 35| 1|//! res = Ok(1);
+ 36| 1|//! }
+ ^0
+ 37| 1|//! res = Ok(0);
+ 38| |//! }
+ 39| |//! // need to be explicit because rustdoc cant infer the return type
+ 40| 1|//! Ok::<(), SomeError>(())
+ 41| 1|//! ```
+ 42| |//!
+ 43| |//! doctest with custom main:
+ 44| |//! ```
+ 45| 1|//! fn some_func() {
+ 46| 1|//! println!("called some_func()");
+ 47| 1|//! }
+ 48| |//!
+ 49| |//! #[derive(Debug)]
+ 50| |//! struct SomeError;
+ 51| |//!
+ 52| |//! extern crate doctest_crate;
+ 53| |//!
+ 54| 1|//! fn doctest_main() -> Result<(), SomeError> {
+ 55| 1|//! some_func();
+ 56| 1|//! doctest_crate::fn_run_in_doctests(2);
+ 57| 1|//! Ok(())
+ 58| 1|//! }
+ 59| |//!
+ 60| |//! // this `main` is not shown as covered, as it clashes with all the other
+ 61| |//! // `main` functions that were automatically generated for doctests
+ 62| |//! fn main() -> Result<(), SomeError> {
+ 63| |//! doctest_main()
+ 64| |//! }
+ 65| |//! ```
+ 66| |
+ 67| |/// doctest attached to fn testing external code:
+ 68| |/// ```
+ 69| 1|/// extern crate doctest_crate;
+ 70| 1|/// doctest_crate::fn_run_in_doctests(3);
+ 71| 1|/// ```
+ 72| |///
+ 73| 1|fn main() {
+ 74| 1| if true {
+ 75| 1| assert_eq!(1, 1);
+ 76| | } else {
+ 77| | assert_eq!(1, 2);
+ 78| | }
+ 79| 1|}
+ 80| |
+ 81| |// FIXME(Swatinem): Fix known issue that coverage code region columns need to be offset by the
+ 82| |// doc comment line prefix (`///` or `//!`) and any additional indent (before or after the doc
+ 83| |// comment characters). This test produces `llvm-cov show` results demonstrating the problem.
+ 84| |//
+ 85| |// One of the above tests now includes: `derive(Debug, PartialEq)`, producing an `llvm-cov show`
+ 86| |// result with a distinct count for `Debug`, denoted by `^1`, but the caret points to the wrong
+ 87| |// column. Similarly, the `if` blocks without `else` blocks show `^0`, which should point at, or
+ 88| |// one character past, the `if` block's closing brace. In both cases, these are most likely off
+ 89| |// by the number of characters stripped from the beginning of each doc comment line: indent
+ 90| |// whitespace, if any, doc comment prefix (`//!` in this case) and (I assume) one space character
+ 91| |// (?). Note, when viewing `llvm-cov show` results in `--color` mode, the column offset errors are
+ 92| |// more pronounced, and show up in more places, with background color used to show some distinct
+ 93| |// code regions with different coverage counts.
+ 94| |//
+ 95| |// NOTE: Since the doc comment line prefix may vary, one possible solution is to replace each
+ 96| |// character stripped from the beginning of doc comment lines with a space. This will give coverage
+ 97| |// results the correct column offsets, and I think it should compile correctly, but I don't know
+ 98| |// what affect it might have on diagnostic messages from the compiler, and whether anyone would care
+ 99| |// if the indentation changed. I don't know if there is a more viable solution.
../coverage/lib/doctest_crate.rs:
1| |/// A function run only from within doctests