dte test coverage


Directory: ./
File: test/config.c
Date: 2025-07-03 15:44:24
Exec Total Coverage
Lines: 164 167 98.2%
Functions: 8 8 100.0%
Branches: 17 22 77.3%

Line Branch Exec Source
1 #include "feature.h"
2 #include <stdlib.h>
3 #include <unistd.h>
4 #include "test.h"
5 #include "config.h"
6 #include "command/error.h"
7 #include "command/macro.h"
8 #include "command/run.h"
9 #include "commands.h"
10 #include "convert.h"
11 #include "editor.h"
12 #include "frame.h"
13 #include "insert.h"
14 #include "mode.h"
15 #include "syntax/state.h"
16 #include "syntax/syntax.h"
17 #include "terminal/terminal.h"
18 #include "util/debug.h"
19 #include "util/path.h"
20 #include "util/readfile.h"
21 #include "util/str-util.h"
22 #include "util/string-view.h"
23 #include "util/xsnprintf.h"
24 #include "window.h"
25
26 #if HAVE_EMBED
27 #include "test-data-embed.h"
28 #else
29 #include "test-data.h"
30 #endif
31
32 1 static void test_builtin_configs(TestContext *ctx)
33 {
34 1 EditorState *e = ctx->userdata;
35 1 HashMap *syntaxes = &e->syntaxes;
36 1 size_t n;
37 1 const BuiltinConfig *editor_builtin_configs = get_builtin_configs_array(&n);
38 1 e->err.print_to_stderr = true;
39
40
2/2
✓ Branch 0 (20→4) taken 76 times.
✓ Branch 1 (20→21) taken 1 times.
77 for (size_t i = 0; i < n; i++) {
41 76 const BuiltinConfig cfg = editor_builtin_configs[i];
42
2/2
✓ Branch 0 (4→5) taken 59 times.
✓ Branch 1 (4→14) taken 17 times.
76 if (str_has_prefix(cfg.name, "syntax/")) {
43
2/2
✓ Branch 0 (5→6) taken 4 times.
✓ Branch 1 (5→7) taken 55 times.
59 if (str_has_prefix(cfg.name, "syntax/inc/")) {
44 4 continue;
45 }
46 // Check that built-in syntax files load without errors
47 55 EXPECT_NULL(find_syntax(syntaxes, path_basename(cfg.name)));
48 55 unsigned int saved_nr_errs = e->err.nr_errors;
49 55 EXPECT_NONNULL(load_syntax(e, cfg.text, cfg.name, 0));
50 55 EXPECT_EQ(e->err.nr_errors, saved_nr_errs);
51 55 EXPECT_NONNULL(find_syntax(syntaxes, path_basename(cfg.name)));
52 } else {
53 // Check that built-in configs and scripts are identical to
54 // their source files
55 17 char path[4096];
56 17 xsnprintf(path, sizeof path, "config/%s", cfg.name);
57 17 char *src;
58 17 ssize_t size = read_file(path, &src, 8u << 20);
59 17 EXPECT_MEMEQ(src, size, cfg.text.data, cfg.text.length);
60 17 free(src);
61 }
62 }
63
64 1 update_all_syntax_styles(&e->syntaxes, &e->styles);
65 1 e->err.print_to_stderr = false;
66 1 }
67
68 20 static void expect_files_equal(TestContext *ctx, const char *path1, const char *path2)
69 {
70 20 size_t filesize_limit = 1u << 20; // 1MiB
71 20 char *buf1;
72 20 ssize_t size1 = read_file(path1, &buf1, filesize_limit);
73
1/2
✗ Branch 0 (3→4) not taken.
✓ Branch 1 (3→6) taken 20 times.
20 if (size1 < 0) {
74 TEST_FAIL("Error reading '%s': %s", path1, strerror(errno));
75 return;
76 }
77 20 test_pass(ctx);
78
79 20 char *buf2;
80 20 ssize_t size2 = read_file(path2, &buf2, filesize_limit);
81
1/2
✗ Branch 0 (8→9) not taken.
✓ Branch 1 (8→12) taken 20 times.
20 if (size2 < 0) {
82 free(buf1);
83 TEST_FAIL("Error reading '%s': %s", path2, strerror(errno));
84 return;
85 }
86 20 test_pass(ctx);
87
88
2/4
✓ Branch 0 (13→14) taken 20 times.
✗ Branch 1 (13→16) not taken.
✗ Branch 2 (15→16) not taken.
✓ Branch 3 (15→17) taken 20 times.
20 if (size1 != size2 || !mem_equal(buf1, buf2, size1)) {
89 TEST_FAIL("Files differ: '%s', '%s'", path1, path2);
90 } else {
91 20 test_pass(ctx);
92 }
93
94 20 free(buf1);
95 20 free(buf2);
96 }
97
98 1 static void test_exec_config(TestContext *ctx)
99 {
100 1 static const char *const outfiles[] = {
101 "env.txt",
102 "crlf.txt",
103 "insert.txt",
104 "join.txt",
105 "change.txt",
106 "thai-utf8.txt",
107 "pipe-from.txt",
108 "pipe-to.txt",
109 "redo1.txt",
110 "redo2.txt",
111 "replace.txt",
112 "shift.txt",
113 "repeat.txt",
114 "wrap.txt",
115 "exec.txt",
116 "move.txt",
117 "delete.txt",
118 "tag.txt",
119 };
120
121 // Delete output files left over from previous runs
122 1 unlink("build/test/thai-tis620.txt");
123
2/2
✓ Branch 0 (7→4) taken 18 times.
✓ Branch 1 (7→8) taken 1 times.
19 FOR_EACH_I(i, outfiles) {
124 18 char out[64];
125 18 xsnprintf(out, sizeof out, "build/test/%s", outfiles[i]);
126 18 unlink(out);
127 }
128
129 // Execute *.dterc files
130 1 EditorState *e = ctx->userdata;
131
2/2
✓ Branch 0 (11→9) taken 18 times.
✓ Branch 1 (11→12) taken 1 times.
19 FOR_EACH_I(i, builtin_configs) {
132 18 const BuiltinConfig config = builtin_configs[i];
133 18 exec_normal_config(e, config.text);
134 }
135
136 // Check that output files have expected contents
137
2/2
✓ Branch 0 (17→13) taken 18 times.
✓ Branch 1 (17→18) taken 1 times.
19 FOR_EACH_I(i, outfiles) {
138 18 char out[64], ref[64];
139 18 xsnprintf(out, sizeof out, "build/test/%s", outfiles[i]);
140 18 xsnprintf(ref, sizeof ref, "test/data/%s", outfiles[i]);
141 18 expect_files_equal(ctx, out, ref);
142 }
143
144
1/2
✓ Branch 0 (19→20) taken 1 times.
✗ Branch 1 (19→21) not taken.
1 if (conversion_supported_by_iconv("UTF-8", "TIS-620")) {
145 1 expect_files_equal(ctx, "build/test/thai-tis620.txt", "test/data/thai-tis620.txt");
146 }
147
148 1 const StringView sv = STRING_VIEW("toggle utf8-bom \\");
149 1 EXPECT_FALSE(e->options.utf8_bom);
150 1 exec_normal_config(e, sv);
151 1 EXPECT_TRUE(e->options.utf8_bom);
152 1 exec_normal_config(e, sv);
153 1 EXPECT_FALSE(e->options.utf8_bom);
154 1 }
155
156 1 static void test_detect_indent(TestContext *ctx)
157 {
158 1 EditorState *e = ctx->userdata;
159 1 EXPECT_FALSE(e->options.detect_indent);
160 1 EXPECT_FALSE(e->options.expand_tab);
161 1 EXPECT_EQ(e->options.indent_width, 8);
162
163 1 static const char cmds[] =
164 "option -r '/test/data/detect-indent\\.ini$' detect-indent 2,4,8;"
165 "open test/data/detect-indent.ini;";
166
167 1 EXPECT_TRUE(handle_normal_command(e, cmds, false));
168 1 EXPECT_EQ(e->buffer->options.detect_indent, 1 << 1 | 1 << 3 | 1 << 7);
169 1 EXPECT_TRUE(e->buffer->options.expand_tab);
170 1 EXPECT_EQ(e->buffer->options.indent_width, 2);
171
172 1 EXPECT_TRUE(handle_normal_command(e, "close", false));
173 1 }
174
175 1 static void test_editor_state(TestContext *ctx)
176 {
177 1 const EditorState *e = ctx->userdata;
178 1 const Buffer *buffer = e->buffer;
179 1 const View *view = e->view;
180 1 const Window *window = e->window;
181 1 const Frame *root_frame = e->root_frame;
182 1 ASSERT_NONNULL(window);
183 1 ASSERT_NONNULL(root_frame);
184 1 ASSERT_NONNULL(buffer);
185 1 ASSERT_NONNULL(view);
186 1 ASSERT_PTREQ(window->view, view);
187 1 ASSERT_PTREQ(window->frame, root_frame);
188 1 ASSERT_PTREQ(window->editor, e);
189 1 ASSERT_PTREQ(view->buffer, buffer);
190 1 ASSERT_PTREQ(view->window, window);
191 1 ASSERT_PTREQ(root_frame->window, window);
192 1 ASSERT_PTREQ(root_frame->parent, NULL);
193
194 1 ASSERT_EQ(window->views.count, 1);
195 1 ASSERT_EQ(buffer->views.count, 1);
196 1 ASSERT_EQ(e->buffers.count, 1);
197 1 ASSERT_PTREQ(window->views.ptrs[0], view);
198 1 ASSERT_PTREQ(buffer->views.ptrs[0], view);
199 1 ASSERT_PTREQ(window_get_first_view(window), view);
200 1 ASSERT_PTREQ(buffer_get_first_view(buffer), view);
201 1 ASSERT_PTREQ(e->buffers.ptrs[0], buffer);
202
203 1 ASSERT_NONNULL(buffer->encoding);
204 1 ASSERT_NONNULL(buffer->blocks.next);
205 1 ASSERT_PTREQ(&buffer->blocks, view->cursor.head);
206 1 ASSERT_PTREQ(buffer->blocks.next, view->cursor.blk);
207 1 ASSERT_PTREQ(buffer->cur_change, &buffer->change_head);
208 1 ASSERT_PTREQ(buffer->saved_change, buffer->cur_change);
209 1 EXPECT_NULL(buffer->display_filename);
210
211 // Note: this isn't necessarily equal to 1 because some UNITTEST
212 // blocks may have already called window_open_empty_buffer()
213 // before init_headless_mode() was entered
214 1 EXPECT_TRUE(buffer->id > 0);
215 1 }
216
217 1 static void test_handle_normal_command(TestContext *ctx)
218 {
219 1 EditorState *e = ctx->userdata;
220 1 EXPECT_TRUE(handle_normal_command(e, "right; left", false));
221 1 EXPECT_TRUE(handle_normal_command(e, ";left;right;;left;right;;;", false));
222 1 EXPECT_FALSE(handle_normal_command(e, "alias 'err", false));
223 1 EXPECT_FALSE(handle_normal_command(e, "refresh; alias 'x", false));
224 1 }
225
226 1 static void test_macro_record(TestContext *ctx)
227 {
228 1 EditorState *e = ctx->userdata;
229 1 MacroRecorder *m = &e->macro;
230 1 EXPECT_PTREQ(e->mode->cmds, &normal_commands);
231
232 1 EXPECT_EQ(m->macro.count, 0);
233 1 EXPECT_EQ(m->prev_macro.count, 0);
234 1 EXPECT_FALSE(macro_is_recording(m));
235 1 EXPECT_TRUE(macro_record(m));
236 1 EXPECT_TRUE(macro_is_recording(m));
237
238 1 EXPECT_TRUE(handle_normal_command(e, "open", false));
239 1 EXPECT_TRUE(handle_input(e, 'x'));
240 1 EXPECT_TRUE(handle_input(e, 'y'));
241 1 EXPECT_TRUE(handle_normal_command(e, "bol", true));
242 1 EXPECT_TRUE(handle_input(e, '-'));
243 1 EXPECT_TRUE(handle_input(e, 'z'));
244 1 EXPECT_TRUE(handle_normal_command(e, "eol; right; insert -m .; new-line", true));
245
246 1 const StringView t1 = STRING_VIEW("test 1\n");
247 1 insert_text(e->view, t1.data, t1.length, true);
248 1 macro_insert_text_hook(m, t1.data, t1.length);
249
250 1 const StringView t2 = STRING_VIEW("-- test 2");
251 1 insert_text(e->view, t2.data, t2.length, true);
252 1 macro_insert_text_hook(m, t2.data, t2.length);
253
254 1 EXPECT_TRUE(macro_is_recording(m));
255 1 EXPECT_TRUE(macro_stop(m));
256 1 EXPECT_FALSE(macro_is_recording(m));
257 1 EXPECT_EQ(m->macro.count, 9);
258 1 EXPECT_EQ(m->prev_macro.count, 0);
259
260 1 static const char cmds[] =
261 "save -f build/test/macro-rec.txt;"
262 "close -f;"
263 "open;"
264 "macro play;"
265 "save -f build/test/macro-out.txt;"
266 "close -f;"
267 "show macro;"
268 "close -f;";
269
270 1 EXPECT_TRUE(handle_normal_command(e, cmds, false));
271 1 expect_files_equal(ctx, "build/test/macro-rec.txt", "build/test/macro-out.txt");
272
273 1 EXPECT_FALSE(macro_is_recording(m));
274 1 EXPECT_TRUE(macro_record(m));
275 1 EXPECT_TRUE(macro_is_recording(m));
276 1 EXPECT_TRUE(handle_input(e, 'x'));
277 1 EXPECT_TRUE(macro_cancel(m));
278 1 EXPECT_FALSE(macro_is_recording(m));
279 1 EXPECT_EQ(m->macro.count, 9);
280 1 EXPECT_EQ(m->prev_macro.count, 0);
281 1 }
282
283 static const TestEntry tests[] = {
284 TEST(test_editor_state),
285 TEST(test_handle_normal_command),
286 TEST(test_builtin_configs),
287 TEST(test_exec_config),
288 TEST(test_detect_indent),
289 TEST(test_macro_record),
290 };
291
292 const TestGroup config_tests = TEST_GROUP(tests);
293
294 DISABLE_WARNING("-Wmissing-prototypes")
295
296 1 void init_headless_mode(TestContext *ctx)
297 {
298 1 EditorState *e = ctx->userdata;
299 1 ASSERT_NONNULL(e);
300 1 exec_rc_files(e, NULL, false);
301 1 e->window = new_window(e);
302 1 e->root_frame = new_root_frame(e->window);
303 1 set_view(window_open_empty_buffer(e->window));
304 1 }
305