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
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

use super::*;

// ========== OptionError Display tests ==========

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_not_found_display() {
    let err = OptionError::NotFound("tabwidth".to_string());
    assert_eq!(format!("{err}"), "option not found: tabwidth");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_already_exists_display() {
    let err = OptionError::AlreadyExists("number".to_string());
    assert_eq!(format!("{err}"), "option already exists: number");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_validation_failed_display() {
    let err = OptionError::ValidationFailed {
        name: "tabwidth".to_string(),
        reason: "must be positive".to_string(),
    };
    assert_eq!(format!("{err}"), "validation failed for 'tabwidth': must be positive");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_type_mismatch_display() {
    let err = OptionError::TypeMismatch {
        name: "number".to_string(),
        expected: "bool",
        got: "integer",
    };
    assert_eq!(format!("{err}"), "type mismatch for 'number': expected bool, got integer");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_alias_conflict_display() {
    let err = OptionError::AliasConflict("nu".to_string());
    assert_eq!(format!("{err}"), "alias conflicts with existing name: nu");
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_scope_mismatch_display() {
    let err = OptionError::ScopeMismatch {
        name: "number".to_string(),
        option_scope: OptionScope::Global,
        requested: OptionScopeId::Buffer(crate::mm::BufferId::from_raw(1)),
    };
    let display = format!("{err}");
    assert!(display.contains("scope mismatch for 'number'"));
    assert!(display.contains("global"));
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_debug() {
    let err = OptionError::NotFound("test".to_string());
    let debug = format!("{err:?}");
    assert!(debug.contains("NotFound"));
    assert!(debug.contains("test"));
}

#[test]
fn test_option_error_clone() {
    let err = OptionError::NotFound("test".to_string());
    let cloned = err.clone();
    assert_eq!(err, cloned);
}

#[test]
fn test_option_error_eq() {
    let err1 = OptionError::NotFound("a".to_string());
    let err2 = OptionError::NotFound("a".to_string());
    let err3 = OptionError::NotFound("b".to_string());
    assert_eq!(err1, err2);
    assert_ne!(err1, err3);
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_option_error_is_std_error() {
    let err: Box<dyn std::error::Error> = Box::new(OptionError::NotFound("test".to_string()));
    let _ = format!("{err}");
}

// ========== SetResult tests ==========

#[test]
fn test_set_result_with_old_value() {
    let result = SetResult {
        old_value: Some(OptionValue::bool(false)),
        new_value: OptionValue::bool(true),
    };
    assert_eq!(result.old_value, Some(OptionValue::bool(false)));
    assert_eq!(result.new_value, OptionValue::bool(true));
}

#[test]
fn test_set_result_without_old_value() {
    let result = SetResult {
        old_value: None,
        new_value: OptionValue::int(4),
    };
    assert!(result.old_value.is_none());
    assert_eq!(result.new_value, OptionValue::int(4));
}

#[test]
#[cfg_attr(coverage_nightly, coverage(off))]
fn test_set_result_debug() {
    let result = SetResult {
        old_value: None,
        new_value: OptionValue::bool(true),
    };
    let debug = format!("{result:?}");
    assert!(debug.contains("SetResult"));
    assert!(debug.contains("old_value"));
    assert!(debug.contains("new_value"));
}

#[test]
fn test_set_result_clone() {
    let result = SetResult {
        old_value: Some(OptionValue::string("old")),
        new_value: OptionValue::string("new"),
    };
    let cloned = result.clone();
    assert_eq!(cloned.old_value, result.old_value);
    assert_eq!(cloned.new_value, result.new_value);
}