xaizek / vifm (License: GPLv2+) (since 2018-12-07)
Vifm is a file manager with curses interface, which provides Vi[m]-like environment for managing objects within file systems, extended with some useful ideas from mutt.
Clone URLs: https://code.reversed.top/user/xaizek/vifm ssh://rocketgit@code.reversed.top/user/xaizek/vifm
v0.13 v0.13-beta v0.14 v0.14-beta v0.14.1 v0.14.2 v0.14.3 master
Commit 916328c8541c83269783015eb53ef3640cb67b9a

Introduce set_user_key() to tests/keys suite
This wraps vle_keys_user_add() for the most common use case with no
special flags.

While at it, make sure return value is consistently asserted to be
success using assert_success() (not `assert_int_equal(0, ...)`) for both
the new wrapper and other uses of vle_keys_user_add().
Author: xaizek
Author date (UTC): 2025-06-08 09:10
Committer name: xaizek
Committer date (UTC): 2025-06-12 17:10
Parent(s): 50c6469988dcbc3de532ead3db679e8852023c45
Signing key: 99DC5E4DB05F6BE2
Tree: bced58966d9f66a0a40a97a8c76a04b03cc177b8
File Lines added Lines deleted
tests/keys/builtin_and_custom.c 10 8
tests/keys/chains.c 2 1
tests/keys/count.c 2 1
tests/keys/def_keys_and_user_mappings.c 4 2
tests/keys/discard_not_full_cmds.c 3 1
tests/keys/foreign_keys.c 3 2
tests/keys/listing.c 6 4
tests/keys/mapping_state.c 3 2
tests/keys/no_regs_long_key.c 3 1
tests/keys/nop.c 2 1
tests/keys/noremap.c 7 9
tests/keys/pick_longest.c 8 6
tests/keys/put_wait_points.c 3 1
tests/keys/remap_builtin.c 5 4
tests/keys/remap_users.c 7 7
tests/keys/silent.c 1 1
tests/keys/suggestions.c 10 8
tests/keys/suite.c 6 0
tests/keys/suite.h 11 0
tests/keys/unmap.c 9 8
tests/keys/users_key_to_key.c 9 8
tests/keys/wait.c 5 3
File tests/keys/builtin_and_custom.c changed (mode: 100644) (index 189f228e8..ec9dbf248)
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5 #include "../../src/modes/wk.h" #include "../../src/modes/wk.h"
6 6
7 #include "suite.h"
8
7 9 SETUP() SETUP()
8 10 { {
9 vle_keys_user_add(L"jo", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
10 vle_keys_user_add(L"jl", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
11 assert_success(set_user_key(L"jo", L"k", NORMAL_MODE));
12 assert_success(set_user_key(L"jl", L"k", NORMAL_MODE));
11 13
12 vle_keys_user_add(L"S", L"dd", NORMAL_MODE, KEYS_FLAG_NONE);
13 vle_keys_user_add(L"Sj", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
14 assert_success(set_user_key(L"S", L"dd", NORMAL_MODE));
15 assert_success(set_user_key(L"Sj", L"k", NORMAL_MODE));
14 16
15 vle_keys_user_add(L"dp", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
17 assert_success(set_user_key(L"dp", L"k", NORMAL_MODE));
16 18
17 vle_keys_user_add(L"ZD", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
19 assert_success(set_user_key(L"ZD", L"k", NORMAL_MODE));
18 20
19 vle_keys_user_add(L"abc", L"", NORMAL_MODE, KEYS_FLAG_NONE);
21 assert_success(set_user_key(L"abc", L"", NORMAL_MODE));
20 22
21 vle_keys_user_add(L"ZT", L"ykk", NORMAL_MODE, KEYS_FLAG_NONE);
23 assert_success(set_user_key(L"ZT", L"ykk", NORMAL_MODE));
22 24 } }
23 25
24 26 TEST(builtin_key_at_sequence_begin) TEST(builtin_key_at_sequence_begin)
File tests/keys/chains.c changed (mode: 100644) (index 09c6e50cb..b13aa0040)
5 5 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
6 6
7 7 #include "builtin_keys.h" #include "builtin_keys.h"
8 #include "suite.h"
8 9
9 10 SETUP() SETUP()
10 11 { {
11 vle_keys_user_add(L"d", L"vz", VISUAL_MODE, KEYS_FLAG_NONE);
12 assert_success(set_user_key(L"d", L"vz", VISUAL_MODE));
12 13 } }
13 14
14 15 TEST(do_not_rerun_chain_on_failure) TEST(do_not_rerun_chain_on_failure)
File tests/keys/count.c changed (mode: 100644) (index 0fcb06bd1..4682fb06b)
9 9 #include "../../src/utils/str.h" #include "../../src/utils/str.h"
10 10
11 11 #include "builtin_keys.h" #include "builtin_keys.h"
12 #include "suite.h"
12 13
13 14 SETUP() SETUP()
14 15 { {
15 vle_keys_user_add(L"abc", L"", NORMAL_MODE, KEYS_FLAG_NONE);
16 assert_success(set_user_key(L"abc", L"", NORMAL_MODE));
16 17 } }
17 18
18 19 TEST(no_number_get_not_def) TEST(no_number_get_not_def)
File tests/keys/def_keys_and_user_mappings.c changed (mode: 100644) (index 957c1f788..3348e4a35)
4 4 #include "../../src/engine/mode.h" #include "../../src/engine/mode.h"
5 5 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
6 6
7 #include "suite.h"
8
7 9 static int handler(wchar_t key); static int handler(wchar_t key);
8 10
9 11 static int counter; static int counter;
 
... ... static int counter;
11 13 SETUP() SETUP()
12 14 { {
13 15 vle_keys_set_def_handler(CMDLINE_MODE, &handler); vle_keys_set_def_handler(CMDLINE_MODE, &handler);
14 vle_keys_user_add(L"s", L":shell", NORMAL_MODE, KEYS_FLAG_NONE);
15 vle_keys_user_add(L"q", L"toto", CMDLINE_MODE, KEYS_FLAG_NONE);
16 assert_success(set_user_key(L"s", L":shell", NORMAL_MODE));
17 assert_success(set_user_key(L"q", L"toto", CMDLINE_MODE));
16 18 } }
17 19
18 20 TEARDOWN() TEARDOWN()
File tests/keys/discard_not_full_cmds.c changed (mode: 100644) (index aa8f3fbb7..4ca0a9dc1)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 SETUP() SETUP()
7 9 { {
8 vle_keys_user_add(L"ui", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
10 assert_success(set_user_key(L"ui", L"k", NORMAL_MODE));
9 11 } }
10 12
11 13 TEST(wait_full_command) TEST(wait_full_command)
File tests/keys/foreign_keys.c changed (mode: 100644) (index a0199db3e..bdc4b671f)
5 5 #include "../../src/modes/wk.h" #include "../../src/modes/wk.h"
6 6
7 7 #include "builtin_keys.h" #include "builtin_keys.h"
8 #include "suite.h"
8 9
9 10 static void key_X(key_info_t key_info, keys_info_t *keys_info); static void key_X(key_info_t key_info, keys_info_t *keys_info);
10 11 static void selector_X(key_info_t key_info, keys_info_t *keys_info); static void selector_X(key_info_t key_info, keys_info_t *keys_info);
 
... ... TEST(add_foreign_key)
31 32
32 33 TEST(replace_user_key_by_foreign_key) TEST(replace_user_key_by_foreign_key)
33 34 { {
34 assert_success(vle_keys_user_add(L"X", L"dd", NORMAL_MODE, KEYS_FLAG_NONE));
35 assert_success(set_user_key(L"X", L"dd", NORMAL_MODE));
35 36
36 37 key_conf_t key = { { &key_X } }; key_conf_t key = { { &key_X } };
37 38 assert_success(vle_keys_foreign_add(L"X", &key, /*is_selector=*/0, assert_success(vle_keys_foreign_add(L"X", &key, /*is_selector=*/0,
 
... ... TEST(foreign_key_with_selector_can_be_redefined)
112 113 NORMAL_MODE)); NORMAL_MODE));
113 114 assert_true(vle_keys_user_exists(L"X", NORMAL_MODE)); assert_true(vle_keys_user_exists(L"X", NORMAL_MODE));
114 115
115 vle_keys_user_add(L"X", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
116 assert_success(set_user_key(L"X", L"j", NORMAL_MODE));
116 117
117 118 last = 0; last = 0;
118 119 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"X"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"X")));
File tests/keys/listing.c changed (mode: 100644) (index c57905611..af4e9f547)
5 5 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
6 6 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
7 7
8 #include "suite.h"
9
8 10 static void process_listing(const wchar_t lhs[], const wchar_t rhs[], static void process_listing(const wchar_t lhs[], const wchar_t rhs[],
9 11 const char descr[]); const char descr[]);
10 12
 
... ... static int nitems;
12 14
13 15 SETUP() SETUP()
14 16 { {
15 vle_keys_user_add(L"hi", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
16 vle_keys_user_add(L"hi2", L"hi", NORMAL_MODE, KEYS_FLAG_NONE);
17 assert_success(set_user_key(L"hi", L"j", NORMAL_MODE));
18 assert_success(set_user_key(L"hi2", L"hi", NORMAL_MODE));
17 19
18 vle_keys_user_add(L"ho", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
19 vle_keys_user_add(L"ha2", L"ho", NORMAL_MODE, KEYS_FLAG_NONE);
20 assert_success(set_user_key(L"ho", L"j", NORMAL_MODE));
21 assert_success(set_user_key(L"ha2", L"ho", NORMAL_MODE));
20 22
21 23 nitems = 0; nitems = 0;
22 24 } }
File tests/keys/mapping_state.c changed (mode: 100644) (index 621bf54d9..6cf84725f)
5 5 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
6 6
7 7 #include "builtin_keys.h" #include "builtin_keys.h"
8 #include "suite.h"
8 9
9 10 static int handler(wchar_t key); static int handler(wchar_t key);
10 11
 
... ... static int mapping_states;
13 14 SETUP() SETUP()
14 15 { {
15 16 vle_keys_set_def_handler(CMDLINE_MODE, &handler); vle_keys_set_def_handler(CMDLINE_MODE, &handler);
16 vle_keys_user_add(L"s", L":shell", NORMAL_MODE, KEYS_FLAG_NONE);
17 vle_keys_user_add(L"M", L"mx", NORMAL_MODE, KEYS_FLAG_NONE);
17 assert_success(set_user_key(L"s", L":shell", NORMAL_MODE));
18 assert_success(set_user_key(L"M", L"mx", NORMAL_MODE));
18 19 } }
19 20
20 21 TEARDOWN() TEARDOWN()
File tests/keys/no_regs_long_key.c changed (mode: 100644) (index cfec89aa7..19369c96e)
4 4 #include "../../src/engine/mode.h" #include "../../src/engine/mode.h"
5 5 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
6 6
7 #include "suite.h"
8
7 9 static int def_handler(wchar_t keys); static int def_handler(wchar_t keys);
8 10 static void silence(int more); static void silence(int more);
9 11
 
... ... SETUP()
19 21 vle_keys_init(MODES_COUNT, mode_flags, &silence); vle_keys_init(MODES_COUNT, mode_flags, &silence);
20 22 vle_mode_set(CMDLINE_MODE, VMT_SECONDARY); vle_mode_set(CMDLINE_MODE, VMT_SECONDARY);
21 23 vle_keys_set_def_handler(CMDLINE_MODE, def_handler); vle_keys_set_def_handler(CMDLINE_MODE, def_handler);
22 vle_keys_user_add(L"asdf", L"ddd", CMDLINE_MODE, KEYS_FLAG_NONE);
24 assert_success(set_user_key(L"asdf", L"ddd", CMDLINE_MODE));
23 25 } }
24 26
25 27 static int static int
File tests/keys/nop.c changed (mode: 100644) (index 24c6e67e5..c0aa7e27f)
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 6 #include "builtin_keys.h" #include "builtin_keys.h"
7 #include "suite.h"
7 8
8 9 SETUP() SETUP()
9 10 { {
10 vle_keys_user_add(L"abc", L"", NORMAL_MODE, KEYS_FLAG_NONE);
11 assert_success(set_user_key(L"abc", L"", NORMAL_MODE));
11 12 } }
12 13
13 14 TEST(nop_no_follow_ok) TEST(nop_no_follow_ok)
File tests/keys/noremap.c changed (mode: 100644) (index 48dbb7ff7..c7ed03985)
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 6 #include "builtin_keys.h" #include "builtin_keys.h"
7 #include "suite.h"
7 8
8 9 TEST(without_noremap) TEST(without_noremap)
9 10 { {
 
... ... TEST(without_noremap)
13 14 assert_int_equal(0, vle_keys_exec(L"j")); assert_int_equal(0, vle_keys_exec(L"j"));
14 15 assert_int_equal(2, last); assert_int_equal(2, last);
15 16
16 assert_int_equal(0, vle_keys_user_add(L"j", L"k", NORMAL_MODE,
17 KEYS_FLAG_NONE));
18 assert_int_equal(0, vle_keys_user_add(L"q", L"j", NORMAL_MODE,
19 KEYS_FLAG_NONE));
17 assert_success(set_user_key(L"j", L"k", NORMAL_MODE));
18 assert_success(set_user_key(L"q", L"j", NORMAL_MODE));
20 19
21 20 assert_int_equal(0, vle_keys_exec(L"j")); assert_int_equal(0, vle_keys_exec(L"j"));
22 21 assert_int_equal(1, last); assert_int_equal(1, last);
 
... ... TEST(with_noremap)
33 32 assert_int_equal(0, vle_keys_exec(L"j")); assert_int_equal(0, vle_keys_exec(L"j"));
34 33 assert_int_equal(2, last); assert_int_equal(2, last);
35 34
36 assert_int_equal(0, vle_keys_user_add(L"j", L"k", NORMAL_MODE,
37 KEYS_FLAG_NONE));
38 assert_int_equal(0, vle_keys_user_add(L"q", L"j", NORMAL_MODE,
39 KEYS_FLAG_NOREMAP));
35 assert_success(set_user_key(L"j", L"k", NORMAL_MODE));
36 assert_success(set_user_key(L"q", L"j", NORMAL_MODE));
37 assert_success(vle_keys_user_add(L"q", L"j", NORMAL_MODE, KEYS_FLAG_NOREMAP));
40 38
41 39 assert_int_equal(0, vle_keys_exec(L"j")); assert_int_equal(0, vle_keys_exec(L"j"));
42 40 assert_int_equal(1, last); assert_int_equal(1, last);
 
... ... TEST(with_noremap)
47 45
48 46 TEST(noremap_functions) TEST(noremap_functions)
49 47 { {
50 assert_success(vle_keys_user_add(L"w", L"k", NORMAL_MODE, KEYS_FLAG_NONE));
48 assert_success(set_user_key(L"w", L"k", NORMAL_MODE));
51 49
52 50 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"w"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"w")));
53 51 assert_true(IS_KEYS_RET_CODE(vle_keys_exec_no_remap(L"w"))); assert_true(IS_KEYS_RET_CODE(vle_keys_exec_no_remap(L"w")));
File tests/keys/pick_longest.c changed (mode: 100644) (index 50aedcacd..6a338a931)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 SETUP() SETUP()
7 9 { {
8 vle_keys_user_add(L"a", L"z", NORMAL_MODE, KEYS_FLAG_NONE);
9 vle_keys_user_add(L"ab", L"x", NORMAL_MODE, KEYS_FLAG_NONE);
10 vle_keys_user_add(L"abc", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
10 assert_success(set_user_key(L"a", L"z", NORMAL_MODE));
11 assert_success(set_user_key(L"ab", L"x", NORMAL_MODE));
12 assert_success(set_user_key(L"abc", L"k", NORMAL_MODE));
11 13
12 vle_keys_user_add(L"q", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
13 vle_keys_user_add(L"qb", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
14 vle_keys_user_add(L"qbc", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
14 assert_success(set_user_key(L"q", L"k", NORMAL_MODE));
15 assert_success(set_user_key(L"qb", L"k", NORMAL_MODE));
16 assert_success(set_user_key(L"qbc", L"k", NORMAL_MODE));
15 17 } }
16 18
17 19 TEST(when_previous_unknown) TEST(when_previous_unknown)
File tests/keys/put_wait_points.c changed (mode: 100644) (index db525f1c7..3fb30b812)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 SETUP() SETUP()
7 9 { {
8 vle_keys_user_add(L"abcdef", L"k", NORMAL_MODE, KEYS_FLAG_NONE);
10 assert_success(set_user_key(L"abcdef", L"k", NORMAL_MODE));
9 11 } }
10 12
11 13 TEST(abcdef) TEST(abcdef)
File tests/keys/remap_builtin.c changed (mode: 100644) (index 0c1466ee8..561175b90)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 TEST(remap_builtin_cmds) TEST(remap_builtin_cmds)
7 9 { {
8 assert_success(vle_keys_user_add(L"ZZ", L":strange movement", NORMAL_MODE,
9 KEYS_FLAG_NONE));
10 assert_success(set_user_key(L"ZZ", L":strange movement", NORMAL_MODE));
10 11 } }
11 12
12 13 TEST(remap_builtin_waitpoint) TEST(remap_builtin_waitpoint)
13 14 { {
14 assert_success(vle_keys_user_add(L"q", L"m", NORMAL_MODE, KEYS_FLAG_NONE));
15 assert_success(set_user_key(L"q", L"m", NORMAL_MODE));
15 16 assert_int_equal(KEYS_WAIT, vle_keys_exec(L"q")); assert_int_equal(KEYS_WAIT, vle_keys_exec(L"q"));
16 17 assert_success(vle_keys_exec(L"qa")); assert_success(vle_keys_exec(L"qa"));
17 18 } }
18 19
19 20 TEST(remap_multi_has_no_wait) TEST(remap_multi_has_no_wait)
20 21 { {
21 assert_success(vle_keys_user_add(L"m", L"j", NORMAL_MODE, KEYS_FLAG_NONE));
22 assert_success(set_user_key(L"m", L"j", NORMAL_MODE));
22 23 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"m"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"m")));
23 24 } }
24 25
File tests/keys/remap_users.c changed (mode: 100644) (index e42072082..2c41fb0c5)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 static int counter; static int counter;
7 9
8 10 TEST(allow_user_key_remap) TEST(allow_user_key_remap)
9 11 { {
10 assert_success(vle_keys_user_add(L"jo", L":do movement", NORMAL_MODE,
11 KEYS_FLAG_NONE));
12 assert_success(vle_keys_user_add(L"jo", L":leave insert mode", NORMAL_MODE,
13 KEYS_FLAG_NONE));
12 assert_success(set_user_key(L"jo", L":do movement", NORMAL_MODE));
13 assert_success(set_user_key(L"jo", L":leave insert mode", NORMAL_MODE));
14 14 } }
15 15
16 16 static int static int
 
... ... handler(wchar_t key)
27 27
28 28 TEST(prevent_stack_overflow) TEST(prevent_stack_overflow)
29 29 { {
30 assert_success(vle_keys_user_add(L"j", L"j", NORMAL_MODE, KEYS_FLAG_NONE));
30 assert_success(set_user_key(L"j", L"j", NORMAL_MODE));
31 31 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"j"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"j")));
32 32
33 assert_success(vle_keys_user_add(L"q", L"q", NORMAL_MODE, KEYS_FLAG_NONE));
33 assert_success(set_user_key(L"q", L"q", NORMAL_MODE));
34 34 assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L"q")); assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L"q"));
35 35
36 36 vle_keys_set_def_handler(NORMAL_MODE, handler); vle_keys_set_def_handler(NORMAL_MODE, handler);
37 37
38 assert_success(vle_keys_user_add(L"t", L"toto", NORMAL_MODE, KEYS_FLAG_NONE));
38 assert_success(set_user_key(L"t", L"toto", NORMAL_MODE));
39 39 assert_success(vle_keys_exec(L"t")); assert_success(vle_keys_exec(L"t"));
40 40
41 41 assert_int_equal(4, counter); assert_int_equal(4, counter);
File tests/keys/silent.c changed (mode: 100644) (index 54e51e33f..4708d48c5)
... ... TEST(removing_user_mapping_from_a_mapping_is_fine)
27 27 vle_keys_add(&keys, 1U, NORMAL_MODE); vle_keys_add(&keys, 1U, NORMAL_MODE);
28 28
29 29 assert_int_equal(0, silence); assert_int_equal(0, silence);
30 vle_keys_user_add(L"a", L"x", NORMAL_MODE, KEYS_FLAG_SILENT);
30 assert_success(vle_keys_user_add(L"a", L"x", NORMAL_MODE, KEYS_FLAG_SILENT));
31 31 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"a"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"a")));
32 32 assert_int_equal(0, silence); assert_int_equal(0, silence);
33 33 } }
File tests/keys/suggestions.c changed (mode: 100644) (index 58e0f21a4..9f7795578)
6 6 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
7 7 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
8 8
9 #include "suite.h"
10
9 11 static void process_suggestion(const wchar_t lhs[], const wchar_t rhs[], static void process_suggestion(const wchar_t lhs[], const wchar_t rhs[],
10 12 const char descr[]); const char descr[]);
11 13
 
... ... static const char *descr;
15 17
16 18 SETUP() SETUP()
17 19 { {
18 vle_keys_user_add(L"hi", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
19 vle_keys_user_add(L"hi2", L"hi", NORMAL_MODE, KEYS_FLAG_NONE);
20 assert_success(set_user_key(L"hi", L"j", NORMAL_MODE));
21 assert_success(set_user_key(L"hi2", L"hi", NORMAL_MODE));
20 22
21 vle_keys_user_add(L"ho", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
22 vle_keys_user_add(L"ha2", L"ho", NORMAL_MODE, KEYS_FLAG_NONE);
23 assert_success(set_user_key(L"ho", L"j", NORMAL_MODE));
24 assert_success(set_user_key(L"ha2", L"ho", NORMAL_MODE));
23 25
24 26 nsuggestions = 0; nsuggestions = 0;
25 27 descr = NULL; descr = NULL;
 
... ... TEST(user_keys_with_prefix_are_listed_no_folding)
45 47
46 48 TEST(user_keys_with_prefix_are_listed_folding) TEST(user_keys_with_prefix_are_listed_folding)
47 49 { {
48 vle_keys_user_add(L"ha3", L"a", NORMAL_MODE, KEYS_FLAG_NONE);
50 assert_success(set_user_key(L"ha3", L"a", NORMAL_MODE));
49 51
50 52 vle_keys_suggest(L"h", &process_suggestion, 0, 1); vle_keys_suggest(L"h", &process_suggestion, 0, 1);
51 53 assert_int_equal(4, nsuggestions); assert_int_equal(4, nsuggestions);
 
... ... TEST(only_custom_suggestions)
94 96
95 97 TEST(suggestions_after_user_mapped_user_prefix) TEST(suggestions_after_user_mapped_user_prefix)
96 98 { {
97 vle_keys_user_add(L"x", L"h", NORMAL_MODE, KEYS_FLAG_NONE);
99 assert_success(set_user_key(L"x", L"h", NORMAL_MODE));
98 100
99 101 vle_keys_suggest(L"x", &process_suggestion, 0, 0); vle_keys_suggest(L"x", &process_suggestion, 0, 0);
100 102 assert_int_equal(4, nsuggestions); assert_int_equal(4, nsuggestions);
 
... ... TEST(suggestions_after_user_mapped_user_prefix)
104 106
105 107 TEST(suggestions_after_user_mapped_builtin_prefix) TEST(suggestions_after_user_mapped_builtin_prefix)
106 108 { {
107 vle_keys_user_add(L"x", L"g", NORMAL_MODE, KEYS_FLAG_NONE);
109 assert_success(set_user_key(L"x", L"g", NORMAL_MODE));
108 110
109 111 vle_keys_suggest(L"x", &process_suggestion, 0, 0); vle_keys_suggest(L"x", &process_suggestion, 0, 0);
110 112 assert_int_equal(3, nsuggestions); assert_int_equal(3, nsuggestions);
 
... ... TEST(suggestions_after_user_mapped_builtin_prefix)
114 116
115 117 TEST(suggestions_after_user_noremapped_builtin_prefix) TEST(suggestions_after_user_noremapped_builtin_prefix)
116 118 { {
117 vle_keys_user_add(L"x", L"g", NORMAL_MODE, KEYS_FLAG_NOREMAP);
119 assert_success(vle_keys_user_add(L"x", L"g", NORMAL_MODE, KEYS_FLAG_NOREMAP));
118 120
119 121 vle_keys_suggest(L"x", &process_suggestion, 0, 0); vle_keys_suggest(L"x", &process_suggestion, 0, 0);
120 122 assert_int_equal(3, nsuggestions); assert_int_equal(3, nsuggestions);
File tests/keys/suite.c changed (mode: 100644) (index 058546d54..50ac3affd)
... ... TEARDOWN()
35 35 vle_keys_reset(); vle_keys_reset();
36 36 } }
37 37
38 int
39 set_user_key(const wchar_t keys[], const wchar_t rhs[], int mode)
40 {
41 return vle_keys_user_add(keys, rhs, mode, KEYS_FLAG_NONE);
42 }
43
38 44 /* vim: set tabstop=2 softtabstop=2 shiftwidth=2 noexpandtab cinoptions-=(0: */ /* vim: set tabstop=2 softtabstop=2 shiftwidth=2 noexpandtab cinoptions-=(0: */
39 45 /* vim: set cinoptions+=t0 filetype=c : */ /* vim: set cinoptions+=t0 filetype=c : */
File tests/keys/suite.h added (mode: 100644) (index 000000000..69e420259)
1 #ifndef VIFM_TESTS__KEYS__SUITE_H__
2 #define VIFM_TESTS__KEYS__SUITE_H__
3
4 #include <wchar.h> /* wchar_t */
5
6 int set_user_key(const wchar_t keys[], const wchar_t rhs[], int mode);
7
8 #endif /* VIFM_TESTS__KEYS__SUITE_H__ */
9
10 /* vim: set tabstop=2 softtabstop=2 shiftwidth=2 noexpandtab cinoptions-=(0 : */
11 /* vim: set cinoptions+=t0 : */
File tests/keys/unmap.c changed (mode: 100644) (index 4bd9e8101..f35271b5b)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 TEST(unmap_users) TEST(unmap_users)
7 9 { {
8 10 assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L",")); assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L","));
9 11 assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L"q")); assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L"q"));
10 12 assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L"s")); assert_int_equal(KEYS_UNKNOWN, vle_keys_exec(L"s"));
11 13
12 assert_success(vle_keys_user_add(L",q", L"k", NORMAL_MODE, KEYS_FLAG_NONE));
13 assert_success(vle_keys_user_add(L",s", L"j", NORMAL_MODE, KEYS_FLAG_NONE));
14 assert_success(set_user_key(L",q", L"k", NORMAL_MODE));
15 assert_success(set_user_key(L",s", L"j", NORMAL_MODE));
14 16
15 17 assert_int_equal(KEYS_WAIT, vle_keys_exec(L",")); assert_int_equal(KEYS_WAIT, vle_keys_exec(L","));
16 18
 
... ... TEST(unmap_users)
27 29
28 30 TEST(unmap_parent_chunk_before_child) TEST(unmap_parent_chunk_before_child)
29 31 { {
30 vle_keys_user_add(L"k", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
31 vle_keys_user_add(L"kk", L"jj", NORMAL_MODE, KEYS_FLAG_NONE);
32 assert_success(set_user_key(L"k", L"j", NORMAL_MODE));
33 assert_success(set_user_key(L"kk", L"jj", NORMAL_MODE));
32 34 assert_true(vle_keys_user_exists(L"k", NORMAL_MODE)); assert_true(vle_keys_user_exists(L"k", NORMAL_MODE));
33 35 assert_true(vle_keys_user_exists(L"kk", NORMAL_MODE)); assert_true(vle_keys_user_exists(L"kk", NORMAL_MODE));
34 36
 
... ... TEST(unmap_parent_chunk_before_child)
41 43
42 44 TEST(unmapping_removes_non_mapped_parents) TEST(unmapping_removes_non_mapped_parents)
43 45 { {
44 assert_success(vle_keys_user_add(L"k1", L"k1", NORMAL_MODE, KEYS_FLAG_NONE));
45 assert_success(vle_keys_user_add(L"k123", L"k123", NORMAL_MODE,
46 KEYS_FLAG_NONE));
46 assert_success(set_user_key(L"k1", L"k1", NORMAL_MODE));
47 assert_success(set_user_key(L"k123", L"k123", NORMAL_MODE));
47 48
48 49 /* Closest mapped parent remains. */ /* Closest mapped parent remains. */
49 50 assert_success(vle_keys_user_remove(L"k123", NORMAL_MODE)); assert_success(vle_keys_user_remove(L"k123", NORMAL_MODE));
 
... ... TEST(unmap_remapped)
59 60 { {
60 61 assert_success(vle_keys_exec(L"j")); assert_success(vle_keys_exec(L"j"));
61 62
62 assert_success(vle_keys_user_add(L"j", L"k", NORMAL_MODE, KEYS_FLAG_NONE));
63 assert_success(set_user_key(L"j", L"k", NORMAL_MODE));
63 64
64 65 assert_success(vle_keys_exec(L"j")); assert_success(vle_keys_exec(L"j"));
65 66
File tests/keys/users_key_to_key.c changed (mode: 100644) (index 62642db33..8ec5240a5)
5 5 #include "../../src/modes/wk.h" #include "../../src/modes/wk.h"
6 6
7 7 #include "builtin_keys.h" #include "builtin_keys.h"
8 #include "suite.h"
8 9
9 10 static void key_selfremove(key_info_t key_info, keys_info_t *keys_info); static void key_selfremove(key_info_t key_info, keys_info_t *keys_info);
10 11
11 12 SETUP() SETUP()
12 13 { {
13 vle_keys_user_add(L"hi", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
14 vle_keys_user_add(L"hi2", L"hi", NORMAL_MODE, KEYS_FLAG_NONE);
14 assert_success(set_user_key(L"hi", L"j", NORMAL_MODE));
15 assert_success(set_user_key(L"hi2", L"hi", NORMAL_MODE));
15 16
16 vle_keys_user_add(L"ho", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
17 vle_keys_user_add(L"ha2", L"ho", NORMAL_MODE, KEYS_FLAG_NONE);
17 assert_success(set_user_key(L"ho", L"j", NORMAL_MODE));
18 assert_success(set_user_key(L"ha2", L"ho", NORMAL_MODE));
18 19 } }
19 20
20 21 TEST(user_key_sequence_cannot_be_empty_even_after_reset) TEST(user_key_sequence_cannot_be_empty_even_after_reset)
 
... ... TEST(user_key_chain_wait)
37 38 TEST(count_is_passed_to_the_next_command) TEST(count_is_passed_to_the_next_command)
38 39 { {
39 40 last_command_register = 0; last_command_register = 0;
40 vle_keys_user_add(L"J", L"dd", NORMAL_MODE, KEYS_FLAG_NONE);
41 assert_success(set_user_key(L"J", L"dd", NORMAL_MODE));
41 42 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"\"aJ"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"\"aJ")));
42 43 assert_int_equal(last_command_register, 'a'); assert_int_equal(last_command_register, 'a');
43 44 } }
 
... ... TEST(user_keys_are_cleared_on_request)
46 47 { {
47 48 last = 0; last = 0;
48 49
49 vle_keys_user_add(L"k", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
50 assert_success(set_user_key(L"k", L"j", NORMAL_MODE));
50 51 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"k"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"k")));
51 52 assert_int_equal(2, last); assert_int_equal(2, last);
52 53
 
... ... TEST(user_keys_are_cleared_on_request)
58 59 TEST(user_key_presence_can_be_checked) TEST(user_key_presence_can_be_checked)
59 60 { {
60 61 assert_false(vle_keys_user_exists(L"k", NORMAL_MODE)); assert_false(vle_keys_user_exists(L"k", NORMAL_MODE));
61 vle_keys_user_add(L"k", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
62 assert_success(set_user_key(L"k", L"j", NORMAL_MODE));
62 63 assert_true(vle_keys_user_exists(L"k", NORMAL_MODE)); assert_true(vle_keys_user_exists(L"k", NORMAL_MODE));
63 64 } }
64 65
 
... ... TEST(removing_user_mapping_from_a_mapping_is_fine)
67 68 keys_add_info_t keys = {WK_x, {{&key_selfremove}}}; keys_add_info_t keys = {WK_x, {{&key_selfremove}}};
68 69 vle_keys_add(&keys, 1U, NORMAL_MODE); vle_keys_add(&keys, 1U, NORMAL_MODE);
69 70
70 vle_keys_user_add(L"a", L"x", NORMAL_MODE, KEYS_FLAG_NONE);
71 assert_success(set_user_key(L"a", L"x", NORMAL_MODE));
71 72 assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"a"))); assert_false(IS_KEYS_RET_CODE(vle_keys_exec(L"a")));
72 73 } }
73 74
File tests/keys/wait.c changed (mode: 100644) (index 8233ae8b9..2c81cea31)
3 3 #include "../../src/engine/keys.h" #include "../../src/engine/keys.h"
4 4 #include "../../src/modes/modes.h" #include "../../src/modes/modes.h"
5 5
6 #include "suite.h"
7
6 8 TEST(wait_flag_turns_short_wait_into_wait) TEST(wait_flag_turns_short_wait_into_wait)
7 9 { {
8 vle_keys_user_add(L"vj", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
10 assert_success(set_user_key(L"vj", L"j", NORMAL_MODE));
9 11 assert_int_equal(KEYS_WAIT_SHORT, vle_keys_exec(L"v")); assert_int_equal(KEYS_WAIT_SHORT, vle_keys_exec(L"v"));
10 vle_keys_user_add(L"vj", L"j", NORMAL_MODE, KEYS_FLAG_WAIT);
12 assert_success(vle_keys_user_add(L"vj", L"j", NORMAL_MODE, KEYS_FLAG_WAIT));
11 13 assert_int_equal(KEYS_WAIT, vle_keys_exec(L"v")); assert_int_equal(KEYS_WAIT, vle_keys_exec(L"v"));
12 vle_keys_user_add(L"vj", L"j", NORMAL_MODE, KEYS_FLAG_NONE);
14 assert_success(set_user_key(L"vj", L"j", NORMAL_MODE));
13 15 assert_int_equal(KEYS_WAIT_SHORT, vle_keys_exec(L"v")); assert_int_equal(KEYS_WAIT_SHORT, vle_keys_exec(L"v"));
14 16 } }
15 17
Hints
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://code.reversed.top/user/xaizek/vifm

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@code.reversed.top/user/xaizek/vifm

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a pull request:
... clone the repository ...
... make some changes and some commits ...
git push origin master