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
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

use super::*;

// ========== OptionScope tests ==========

#[test]
fn test_option_scope_default() {
    assert_eq!(OptionScope::default(), OptionScope::Global);
}

#[test]
fn test_option_scope_display_names() {
    assert_eq!(OptionScope::Global.display_name(), "global");
    assert_eq!(OptionScope::Buffer.display_name(), "buffer");
    assert_eq!(OptionScope::Window.display_name(), "window");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_scope_display() {
    assert_eq!(format!("{}", OptionScope::Global), "global");
    assert_eq!(format!("{}", OptionScope::Buffer), "buffer");
    assert_eq!(format!("{}", OptionScope::Window), "window");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_scope_debug() {
    let debug = format!("{:?}", OptionScope::Global);
    assert_eq!(debug, "Global");
}

#[test]
fn test_option_scope_clone() {
    let scope = OptionScope::Buffer;
    let cloned = scope;
    assert_eq!(scope, cloned);
}

#[test]
fn test_option_scope_eq() {
    assert_eq!(OptionScope::Global, OptionScope::Global);
    assert_ne!(OptionScope::Global, OptionScope::Buffer);
    assert_ne!(OptionScope::Buffer, OptionScope::Window);
}

#[test]
fn test_option_scope_hash() {
    use std::collections::HashSet;
    let mut set = HashSet::new();
    set.insert(OptionScope::Global);
    set.insert(OptionScope::Buffer);
    set.insert(OptionScope::Window);
    set.insert(OptionScope::Global); // duplicate
    assert_eq!(set.len(), 3);
}

// ========== OptionScopeId tests ==========

#[test]
fn test_option_scope_id_default() {
    assert_eq!(OptionScopeId::default(), OptionScopeId::Global);
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_scope_id_display_global() {
    assert_eq!(format!("{}", OptionScopeId::Global), "global");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_scope_id_display_buffer() {
    let id = BufferId::from_raw(42);
    let display = format!("{}", OptionScopeId::Buffer(id));
    assert!(display.contains("buffer"));
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_scope_id_display_window() {
    let id = WindowId::from_raw(7);
    let display = format!("{}", OptionScopeId::Window(id));
    assert!(display.contains("window"));
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_scope_id_debug() {
    let scope_id = OptionScopeId::Global;
    let debug = format!("{scope_id:?}");
    assert_eq!(debug, "Global");
}

#[test]
fn test_option_scope_id_eq() {
    let id = BufferId::from_raw(1);
    assert_eq!(OptionScopeId::Global, OptionScopeId::Global);
    assert_eq!(OptionScopeId::Buffer(id), OptionScopeId::Buffer(id));
    assert_ne!(OptionScopeId::Global, OptionScopeId::Buffer(id));
}

#[test]
fn test_option_scope_id_hash() {
    use std::collections::HashSet;
    let id1 = BufferId::from_raw(1);
    let id2 = BufferId::from_raw(2);
    let mut set = HashSet::new();
    set.insert(OptionScopeId::Global);
    set.insert(OptionScopeId::Buffer(id1));
    set.insert(OptionScopeId::Buffer(id2));
    set.insert(OptionScopeId::Global); // duplicate
    assert_eq!(set.len(), 3);
}

#[test]
fn test_option_scope_id_clone() {
    let id = BufferId::from_raw(5);
    let scope_id = OptionScopeId::Buffer(id);
    let cloned = scope_id;
    assert_eq!(scope_id, cloned);
}