os-test-framework 0.4.0

Test framework for embedded systems and OS kernels.
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
125

//! # os-test-framework
//!
//! Test framework for embedded systems and OS kernels.
//!
//! `os-test-framework` requires `alloc`, so your kernel will need a `global-allocator`.
//!
//! ## Getting Started
//!
//! First, enable `custom_test_frameworks`, set `test_runner` as the test runner
//! from `os-test-framework`, and `reexport_test_harness_main`.
//!
//! ```rust,ignore
//! #![feature(custom_test_frameworks)]
//! #![reexport_test_harness_main = "test_main"]
//! #![test_runner(os_test_framework::run_tests)]
//! ```
//!
//! Implement `Platform`. The framework writes output through
//! `Platform::print` and finishes the run through `Platform::exit`:
//!
//! ```rust,ignore
//! use core::fmt::Arguments;
//! use os_test_framework::{ExitState, Platform};
//!
//! struct MyPlatform;
//!
//! impl Platform for MyPlatform {
//!     fn print(&mut self, args: Arguments) {
//!         let _ = args;
//!         todo!()
//!     }
//!
//!     fn exit(&self, state: ExitState) -> ! {
//!         match state {
//!             ExitState::Success => todo!(),
//!             ExitState::Failed => todo!(),
//!         }
//!     }
//! }
//! ```
//!
//! Call `init_platform` with your `Platform`, and `test_main` from your kernel
//! entry point:
//!
//! ```rust,ignore
//! use os_test_framework::init_platform;
//!
//! fn kernel_entry() {
//!     init_platform(MyPlatform);
//!     test_main();
//! }
//! ```
//!
//! Forward panics from your OS to `os-test-framework`:
//!
//! ```rust,ignore
//! os_test_framework::forward_panic!();
//! ```
//!
//! ## Adding A Test
//!
//! You can declare tests like this:
//!
//! ```rust,ignore
//! use os_test_framework::test;
//!
//! test! {
//!     "Hello" {
//!         assert!(true);
//!     }
//! }
//! ```
//!
//! You can add multiple tests in the same file:
//!
//! ```rust,ignore
//! use os_test_framework::test;
//!
//! test! {
//!     "Hello" {
//!         assert!(true);
//!     }
//! }
//!
//! test! {
//!     "Hello2" {
//!         assert!(true);
//!     }
//! }
//! ```
#![no_std]

use owo_colors::OwoColorize;

extern crate alloc;

mod panic;
mod platform;
#[doc(hidden)]
pub mod __private {
    pub use crate::_run_test;
    pub use crate::printing::_print;
}

pub use crate::{panic::*, platform::*};

mod make_test;
mod printing;

pub fn run_tests(tests: &[&dyn Fn()]) -> ! {
    println!("\nRunning {} tests", tests.len().bold());

    for test in tests {
        test()
    }

    platform().lock().exit(ExitState::Success);
}

#[doc(hidden)]
pub fn _run_test(name: &str, func: impl FnOnce()) {
    print!("{}", name);
    func();
    println!(" {}", "OK".green().bold());
}