kbvm 0.1.5

An implementation of the XKB specification
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
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

use {
    crate::{config::DEFAULT_INCLUDE_DIR, xkb::Context},
    std::{env::set_var, sync::Once},
};

fn init_env() {
    static ONCE: Once = Once::new();
    ONCE.call_once(|| unsafe {
        set_var("HOME", "a");
        set_var("XDG_CONFIG_HOME", "b");
        set_var("XKB_CONFIG_EXTRA_PATH", "c");
        set_var("XKB_CONFIG_ROOT", "d");
        set_var("XLOCALEDIR", "e");
        set_var("XCOMPOSEFILE", "f");
        set_var("XKB_DEFAULT_RULES", "g");
        set_var("XKB_DEFAULT_MODEL", "h");
        set_var("XKB_DEFAULT_LAYOUT", "i");
        set_var("XKB_DEFAULT_VARIANT", "j");
        set_var("XKB_DEFAULT_OPTIONS", "k");
    })
}

#[test]
fn default_env() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    let context = context.build();
    let e = &context.env;
    assert_eq!(e.home, None);
    assert_eq!(e.xlocaledir, "/usr/share/X11/locale");
    assert_eq!(e.xcomposefile, None);
    assert_eq!(e.xkb_default_rules, "evdev");
    assert_eq!(e.xkb_default_model, "pc105");
    assert_eq!(e.xkb_default_layout, "us");
    assert_eq!(e.xkb_default_variant, "");
    assert_eq!(e.xkb_default_options, "");
    assert_eq!(e.xkb_config_extra_path, "/etc/xkb");
    assert_eq!(e.xkb_config_root, DEFAULT_INCLUDE_DIR);
}

#[test]
fn env_env() {
    init_env();
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(true);
    let context = context.build();
    let e = &context.env;
    assert_eq!(e.home.as_deref(), Some("a"));
    assert_eq!(e.xkb_config_extra_path, "c");
    assert_eq!(e.xkb_config_root, "d");
    assert_eq!(e.xlocaledir, "e");
    assert_eq!(e.xcomposefile.as_deref(), Some("f"));
    assert_eq!(e.xkb_default_rules, "g");
    assert_eq!(e.xkb_default_model, "h");
    assert_eq!(e.xkb_default_layout, "i");
    assert_eq!(e.xkb_default_variant, "j");
    assert_eq!(e.xkb_default_options, "k");
}

#[test]
fn system_paths() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    context.enable_default_includes(true);
    let c = context.build();
    assert_eq!(c.paths.len(), 2);
    assert_eq!(c.paths[0].as_os_str(), "/etc/xkb");
    assert_eq!(c.paths[1].as_os_str(), DEFAULT_INCLUDE_DIR);
}

#[test]
fn system_and_env_paths() {
    init_env();
    let mut context = Context::builder();
    context.clear();
    context.enable_default_includes(true);
    context.enable_environment(true);
    let c = context.build();
    assert_eq!(c.paths.len(), 4);
    assert_eq!(c.paths[0].as_os_str(), "b/xkb");
    assert_eq!(c.paths[1].as_os_str(), "a/.xkb");
    assert_eq!(c.paths[2].as_os_str(), "c");
    assert_eq!(c.paths[3].as_os_str(), "d");
}

#[test]
fn prefix_and_suffix() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    context.enable_default_includes(true);
    context.prepend_path("prefix1");
    context.prepend_path("prefix2");
    context.append_path("suffix1");
    context.append_path("suffix2");
    let c = context.build();
    assert_eq!(c.paths.len(), 6);
    assert_eq!(c.paths[0].as_os_str(), "prefix2");
    assert_eq!(c.paths[1].as_os_str(), "prefix1");
    assert_eq!(c.paths[2].as_os_str(), "/etc/xkb");
    assert_eq!(c.paths[3].as_os_str(), DEFAULT_INCLUDE_DIR);
    assert_eq!(c.paths[4].as_os_str(), "suffix1");
    assert_eq!(c.paths[5].as_os_str(), "suffix2");
}

#[test]
fn default_extra_paths() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    let c = context.build();
    assert_eq!(c.load_extra_rules, false);
}

#[test]
fn enable_extra_paths() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    context.load_extra_rules(true);
    let c = context.build();
    assert_eq!(c.load_extra_rules, true);
}

#[test]
fn default_limits() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    let c = context.build();
    assert_eq!(c.max_includes, 1024);
    assert_eq!(c.max_include_depth, 128);
    assert_eq!(c.max_runtime, 500_000);
    assert_eq!(c.max_compose_rules, 100_000);
}

#[test]
fn custom_limits() {
    let mut context = Context::builder();
    context.clear();
    context.enable_environment(false);
    context.max_includes(123);
    context.max_include_depth(456);
    context.max_runtime(789);
    context.max_compose_rules(12);
    let c = context.build();
    assert_eq!(c.max_includes, 123);
    assert_eq!(c.max_include_depth, 456);
    assert_eq!(c.max_runtime, 789);
    assert_eq!(c.max_compose_rules, 12);
}