libtest2 0.0.3

An experimental replacement for libtest
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! An experimental replacement for libtest
//!
//! # Usage
//!
//! To use this, you most likely want to add a manual `[[test]]` section to
//! `Cargo.toml` and set `harness = false`. For example:
//!
//! ```toml
//! [[test]]
//! name = "mytest"
//! path = "tests/mytest.rs"
//! harness = false
//! ```
//!
//! And in `tests/mytest.rs` you would call [`libtest2_main`], passing it each of your tests:
//!
//! ```no_run
//! # use libtest2::RunError;
//! # use libtest2::RunResult;
//! # use libtest2::TestContext;
//! # use libtest2::libtest2_main;
//! fn check_toph(_context: &TestContext) -> RunResult {
//!     Ok(())
//! }
//!
//! libtest2_main!(check_toph);
//! ```
//!

#![cfg_attr(docsrs, feature(doc_auto_cfg))]
//#![warn(clippy::print_stderr)]
#![warn(clippy::print_stdout)]

pub use libtest2_harness::Harness;
pub use libtest2_harness::RunError;
pub use libtest2_harness::RunResult;
pub use libtest2_harness::TestContext;
pub use libtest2_harness::TestKind;
pub use libtest2_harness::ERROR_EXIT_CODE;

use libtest2_harness::Case;
use libtest2_harness::Source;

pub struct Trial {
    name: String,
    #[allow(clippy::type_complexity)]
    runner: Box<dyn Fn(&TestContext) -> Result<(), RunError> + Send + Sync>,
}

impl Trial {
    pub fn test(
        name: impl Into<String>,
        runner: impl Fn(&TestContext) -> Result<(), RunError> + Send + Sync + 'static,
    ) -> Self {
        Self {
            name: name.into(),
            runner: Box::new(runner),
        }
    }
}

impl Case for Trial {
    fn name(&self) -> &str {
        &self.name
    }
    fn kind(&self) -> TestKind {
        Default::default()
    }
    fn source(&self) -> Option<&Source> {
        None
    }
    fn exclusive(&self, _: &TestContext) -> bool {
        false
    }

    fn run(&self, context: &TestContext) -> Result<(), RunError> {
        (self.runner)(context)
    }
}

/// Expands to the test harness
#[macro_export]
macro_rules! libtest2_main {
    ( $( $test:path ),* $(,)*) => {
        fn main() {
            let harness = $crate::Harness::new();
            let harness = match harness.with_env() {
                Ok(harness) => harness,
                Err(err) => {
                    eprintln!("{err}");
                    ::std::process::exit(1);
                }
            };
            let harness = match harness.parse() {
                Ok(harness) => harness,
                Err(err) => {
                    eprintln!("{err}");
                    ::std::process::exit(1);
                }
            };
            let harness = match harness.discover([
                $($crate::Trial::test(::std::stringify!($test), $test)),*
            ]) {
                Ok(harness) => harness,
                Err(err) => {
                    eprintln!("{err}");
                    ::std::process::exit($crate::ERROR_EXIT_CODE)
                }
            };
            match harness.run() {
                Ok(true) => ::std::process::exit(0),
                Ok(false) => ::std::process::exit($crate::ERROR_EXIT_CODE),
                Err(err) => {
                    eprintln!("{err}");
                    ::std::process::exit($crate::ERROR_EXIT_CODE)
                }
            }
        }
    }
}

#[doc = include_str!("../README.md")]
#[cfg(doctest)]
pub struct ReadmeDoctests;