kitest 0.5.0

A composable test harness toolkit with room to fly.
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

use std::borrow::Cow;

use crate::{
    TestHarness,
    capture::DefaultPanicHookProvider,
    filter::NoFilter,
    formatter::no::NoFormatter,
    ignore::{IgnoreStatus, NoIgnore},
    panic::{NoPanicHandler, PanicExpectation},
    runner::{SimpleRunner, scope::NoScopeFactory},
    test::{Test, TestFn, TestFnHandle, TestMeta, TestOrigin},
};

pub struct BuildTest<Extra> {
    pub func: TestFnHandle,
    pub name: Cow<'static, str>,
    pub ignore: IgnoreStatus,
    pub should_panic: PanicExpectation,
    pub origin: Option<TestOrigin>,
    pub extra: Extra,
}

impl Default for BuildTest<()> {
    fn default() -> Self {
        Self {
            func: TestFnHandle::Static(&|| ()),
            name: Default::default(),
            ignore: Default::default(),
            should_panic: Default::default(),
            origin: Default::default(),
            extra: Default::default(),
        }
    }
}

impl<Extra> From<BuildTest<Extra>> for Test<Extra> {
    fn from(value: BuildTest<Extra>) -> Self {
        Test::new(
            value.func,
            TestMeta {
                name: value.name,
                ignore: value.ignore,
                should_panic: value.should_panic,
                origin: value.origin,
                extra: value.extra,
            },
        )
    }
}

impl<F> From<F> for TestFnHandle
where
    F: TestFn + Send + Sync + 'static,
{
    fn from(value: F) -> Self {
        TestFnHandle::Owned(Box::new(value))
    }
}

macro_rules! test {
    {$($field:ident: $value:expr),* $(,)?} => {
        $crate::test::Test::from($crate::test_support::BuildTest {
            $($field: From::from($value),)*
            ..($crate::test_support::BuildTest {
                name: concat!(module_path!(), "::", file!(), ":", line!(), ":", column!()).into(),
                origin: $crate::origin!(),
                ..Default::default()
            })
        })
    };
}

pub(crate) use test;

pub fn harness(
    tests: &[Test],
) -> TestHarness<
    '_,
    (),
    NoFilter,
    NoIgnore,
    NoPanicHandler,
    SimpleRunner<DefaultPanicHookProvider, NoScopeFactory>,
    NoFormatter,
> {
    TestHarness {
        tests,
        filter: NoFilter,
        ignore: NoIgnore,
        panic_handler: NoPanicHandler,
        runner: SimpleRunner::default(),
        formatter: NoFormatter,
    }
}

macro_rules! nonzero {
    (0) => {
        compile_error!("0 is zero")
    };

    ($value:literal) => {
        std::convert::TryFrom::try_from($value).unwrap()
    };
}

pub(crate) use nonzero;