reovim-kernel 0.14.3

Core kernel mechanisms for reovim (Linux kernel/ equivalent)
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

use super::super::*;

#[test]
fn test_default_state() {
    assert_eq!(RuntimeState::default(), RuntimeState::Booting);
}

#[test]
fn test_is_running() {
    assert!(!RuntimeState::Booting.is_running());
    assert!(RuntimeState::Running.is_running());
    assert!(!RuntimeState::Stopping.is_running());
    assert!(!RuntimeState::Emergency.is_running());
}

#[test]
fn test_is_shutting_down() {
    assert!(!RuntimeState::Booting.is_shutting_down());
    assert!(!RuntimeState::Running.is_shutting_down());
    assert!(RuntimeState::Stopping.is_shutting_down());
    assert!(RuntimeState::Emergency.is_shutting_down());
}

#[test]
fn test_can_accept_work() {
    assert!(!RuntimeState::Booting.can_accept_work());
    assert!(RuntimeState::Running.can_accept_work());
    assert!(!RuntimeState::Stopping.can_accept_work());
    assert!(!RuntimeState::Emergency.can_accept_work());
}

#[test]
fn test_is_terminal() {
    assert!(!RuntimeState::Booting.is_terminal());
    assert!(!RuntimeState::Running.is_terminal());
    assert!(RuntimeState::Stopping.is_terminal());
    assert!(RuntimeState::Emergency.is_terminal());
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_display() {
    assert_eq!(format!("{}", RuntimeState::Booting), "Booting");
    assert_eq!(format!("{}", RuntimeState::Running), "Running");
    assert_eq!(format!("{}", RuntimeState::Stopping), "Stopping");
    assert_eq!(format!("{}", RuntimeState::Emergency), "Emergency");
}

#[test]
#[allow(clippy::clone_on_copy)] // Intentionally testing Clone impl
fn test_clone_and_copy() {
    let state = RuntimeState::Running;
    let cloned = state.clone();
    let copied = state;
    assert_eq!(state, cloned);
    assert_eq!(state, copied);
}

#[test]
fn test_hash() {
    use std::collections::HashSet;
    let mut set = HashSet::new();
    set.insert(RuntimeState::Booting);
    set.insert(RuntimeState::Running);
    assert!(set.contains(&RuntimeState::Booting));
    assert!(set.contains(&RuntimeState::Running));
    assert!(!set.contains(&RuntimeState::Stopping));
}