dte test coverage


Directory: ./
File: test/init.c
Date: 2025-09-07 23:01:39
Exec Total Coverage
Lines: 155 161 96.3%
Functions: 6 6 100.0%
Branches: 2 4 50.0%

Line Branch Exec Source
1 #include <errno.h>
2 #include <fcntl.h>
3 #include <limits.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <sys/stat.h>
7 #include <unistd.h>
8 #include "test.h"
9 #include "editor.h"
10 #include "exec.h"
11 #include "terminal/color.h"
12 #include "terminal/terminal.h"
13 #include "trace.h"
14 #include "util/fd.h"
15 #include "util/log.h"
16 #include "util/path.h"
17 #include "util/xreadwrite.h"
18 #include "version.h"
19
20 1 static void test_process_sanity(TestContext *ctx)
21 {
22 // Note that if this fails, there'll only be (at best) an "aborted"
23 // message, since there's no stderr for test_fail() to use
24 1 ASSERT_TRUE(fd_is_valid(STDERR_FILENO));
25
26 1 ASSERT_NONNULL(freopen("/dev/null", "r", stdin));
27 1 ASSERT_NONNULL(freopen("/dev/null", "w", stdout));
28 1 }
29
30 1 static void test_posix_sanity(TestContext *ctx)
31 {
32 // This is not guaranteed by ISO C99, but it is required by POSIX
33 // and is relied upon by this codebase.
34 // See: https://pubs.opengroup.org/onlinepubs/9799919799/basedefs/limits.h.html#tag_14_26_03_06
35 1 ASSERT_EQ(CHAR_BIT, 8);
36 1 ASSERT_TRUE(sizeof(int) >= 4);
37 1 ASSERT_TRUE(BITSIZE(int) >= 32);
38 1 ASSERT_EQ(SCHAR_MIN, -128);
39 1 ASSERT_EQ(SCHAR_MAX, 127);
40 1 ASSERT_EQ(UCHAR_MAX, 255);
41 1 ASSERT_TRUE(UINT_MAX >= 0xFFFFFFFFu);
42 1 ASSERT_TRUE(INT_MAX >= 0x7FFFFFFF);
43 1 ASSERT_TRUE(INT_MIN <= -0x80000000);
44
45 IGNORE_WARNING("-Wformat-truncation")
46
47 // Some snprintf(3) implementations historically returned -1 in case of
48 // truncation. C99 and POSIX 2001 both require that it return the full
49 // size of the formatted string, as if there had been enough space.
50 1 char buf[8] = "........";
51 1 ASSERT_EQ(snprintf(buf, 8, "0123456789"), 10);
52 1 ASSERT_EQ(buf[7], '\0');
53 1 EXPECT_STREQ(buf, "0123456");
54
55 // C99 and POSIX 2001 also require the same behavior as above when the
56 // size argument is 0 (and allow the buffer argument to be NULL).
57 1 ASSERT_EQ(snprintf(NULL, 0, "987654321"), 9);
58
59 UNIGNORE_WARNINGS
60 1 }
61
62 // Note: this must be ordered before a successful call to log_open()
63 // (i.e. the one in test_init()), so as not to trigger the BUG_ON()
64 // assertions at the top of log_open()
65 1 static void test_log_open_errors(TestContext *ctx)
66 {
67 1 const LogLevel none = LOG_LEVEL_NONE;
68 1 const LogLevel info = LOG_LEVEL_INFO;
69 1 errno = 0;
70 1 ASSERT_EQ(log_open("/dev/null", none, false), none);
71 1 EXPECT_EQ(errno, 0);
72 1 ASSERT_EQ(log_open("build/test/non-existent-dir/x", info, false), none);
73 1 EXPECT_EQ(errno, ENOENT);
74
75
1/2
✓ Branch 0 (9→10) taken 1 times.
✗ Branch 1 (9→13) not taken.
1 if (access("/dev/full", W_OK) == 0) {
76 1 errno = 0;
77 1 ASSERT_EQ(log_open("/dev/full", info, false), none);
78 1 EXPECT_EQ(errno, ENOSPC);
79 }
80
81 1 int tty = xopen("/dev/tty", O_WRONLY | O_CLOEXEC | O_NOCTTY, 0);
82
1/2
✗ Branch 0 (14→15) not taken.
✓ Branch 1 (14→23) taken 1 times.
1 if (tty >= 0) {
83 ASSERT_TRUE(tty > STDERR_FILENO);
84 ASSERT_TRUE(is_controlling_tty(tty));
85 EXPECT_EQ(xclose(tty), 0);
86 errno = 0;
87 ASSERT_EQ(log_open("/dev/tty", info, false), none);
88 EXPECT_EQ(errno, EINVAL);
89 }
90 1 }
91
92 1 static void test_trace_flags_from_str(TestContext *ctx)
93 {
94 1 if (!TRACE_LOGGING_ENABLED) {
95 return;
96 }
97
98 1 EXPECT_EQ(trace_flags_from_str("output"), TRACEFLAG_OUTPUT);
99 1 EXPECT_EQ(trace_flags_from_str(",x,, ,output,,"), TRACEFLAG_OUTPUT);
100 1 EXPECT_EQ(trace_flags_from_str("command,input"), TRACEFLAG_COMMAND | TRACEFLAG_INPUT);
101 1 EXPECT_EQ(trace_flags_from_str("command,inpu"), TRACEFLAG_COMMAND);
102 1 EXPECT_EQ(trace_flags_from_str(""), 0);
103 1 EXPECT_EQ(trace_flags_from_str(","), 0);
104 1 EXPECT_EQ(trace_flags_from_str("a"), 0);
105 }
106
107 1 static void test_init(TestContext *ctx)
108 {
109 1 char *home = path_absolute("build/test/HOME");
110 1 char *dte_home = path_absolute("build/test/DTE_HOME");
111 1 ASSERT_NONNULL(home);
112 1 ASSERT_NONNULL(dte_home);
113
114 1 ASSERT_TRUE(mkdir(home, 0755) == 0 || errno == EEXIST);
115 1 ASSERT_TRUE(mkdir(dte_home, 0755) == 0 || errno == EEXIST);
116
117 1 ASSERT_EQ(setenv("HOME", home, 1), 0);
118 1 ASSERT_EQ(setenv("DTE_HOME", dte_home, 1), 0);
119 1 ASSERT_EQ(setenv("XDG_RUNTIME_DIR", dte_home, 1), 0);
120 1 ASSERT_EQ(setenv("TZ", "UTC", 1), 0);
121 1 ASSERT_EQ(unsetenv("TERM"), 0);
122 1 ASSERT_EQ(unsetenv("COLORTERM"), 0);
123
124 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_CRITICAL));
125 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_ERROR));
126 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_WARNING));
127 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_NOTICE));
128 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_INFO));
129 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_DEBUG));
130 1 EXPECT_FALSE(log_level_enabled(LOG_LEVEL_TRACE));
131 1 EXPECT_FALSE(log_level_debug_enabled());
132
133 1 const LogLevel def_lvl = log_level_default();
134 1 const LogLevel max_lvl = TRACE_LOGGING_ENABLED ? LOG_LEVEL_TRACE : def_lvl;
135 1 const LogLevel req_lvl = LOG_LEVEL_TRACE;
136 1 ASSERT_EQ(log_open("build/test/log.txt", req_lvl, false), max_lvl);
137 1 EXPECT_TRUE(log_level_enabled(LOG_LEVEL_CRITICAL));
138 1 EXPECT_TRUE(log_level_enabled(LOG_LEVEL_ERROR));
139 1 EXPECT_TRUE(log_level_enabled(LOG_LEVEL_WARNING));
140 1 EXPECT_TRUE(log_level_enabled(LOG_LEVEL_NOTICE));
141 1 EXPECT_TRUE(log_level_enabled(LOG_LEVEL_INFO));
142 1 EXPECT_EQ(log_level_enabled(LOG_LEVEL_DEBUG), DEBUG_LOGGING_ENABLED);
143 1 EXPECT_EQ(log_level_enabled(LOG_LEVEL_TRACE), TRACE_LOGGING_ENABLED);
144 1 EXPECT_EQ(log_level_debug_enabled(), DEBUG_LOGGING_ENABLED);
145 1 EXPECT_FALSE(log_trace_enabled(TRACEFLAGS_ALL));
146 1 LOG_CRITICAL("%s: testing LOG_CRITICAL()", __func__);
147 1 LOG_ERROR("%s: testing LOG_ERROR()", __func__);
148 1 LOG_WARNING("%s: testing LOG_WARNING()", __func__);
149 1 LOG_NOTICE("%s: testing LOG_NOTICE()", __func__);
150 1 LOG_INFO("%s: testing LOG_INFO()", __func__);
151 1 LOG_DEBUG("%s: testing LOG_DEBUG()", __func__);
152 1 LOG_TRACE(TRACEFLAGS_ALL, "should always fail; trace flags not yet set");
153 1 log_write(LOG_LEVEL_TRACE, STRN("as above"));
154 1 log_write(LOG_LEVEL_INFO, STRN("testing log_write()"));
155
156 1 const TraceLoggingFlags all = TRACEFLAGS_ALL;
157 1 set_trace_logging_flags(all);
158 1 EXPECT_EQ(log_trace_enabled(all), TRACE_LOGGING_ENABLED);
159 1 LOG_TRACE(all, "%s: testing LOG_TRACE()", __func__);
160 1 TRACE_CMD("%s: testing TRACE_CMD()", __func__);
161 1 TRACE_INPUT("%s: testing TRACE_INPUT()", __func__);
162 1 TRACE_OUTPUT("%s: testing TRACE_OUTPUT()", __func__);
163
164 1 EditorState *e = init_editor_state(home, dte_home);
165 1 ASSERT_NONNULL(e);
166 1 ASSERT_NONNULL(e->user_config_dir);
167 1 ASSERT_NONNULL(e->home_dir.data);
168 1 EXPECT_STREQ(e->user_config_dir, dte_home);
169 1 EXPECT_STRVIEW_EQ_CSTRING(e->home_dir, home);
170 1 free(home);
171 1 free(dte_home);
172 1 e->options.lock_files = false;
173 1 ctx->userdata = e;
174
175 1 Terminal *term = &e->terminal;
176 1 EXPECT_EQ(term->features, 0);
177 1 EXPECT_EQ(term->width, 0);
178 1 EXPECT_EQ(term->height, 0);
179 1 term_init(term, "decansi", NULL);
180 1 EXPECT_EQ(term->features, TFLAG_8_COLOR);
181 1 EXPECT_EQ(term->width, 80);
182 1 EXPECT_EQ(term->height, 24);
183
184 1 const char *ver = getenv("DTE_VERSION");
185 1 EXPECT_NONNULL(ver);
186 1 EXPECT_STREQ(ver, VERSION);
187 1 }
188
189 1 static void test_deinit(TestContext *ctx)
190 {
191 // Make sure default Terminal state wasn't changed
192 1 EditorState *e = ctx->userdata;
193 1 const Terminal *term = &e->terminal;
194 1 EXPECT_EQ(term->width, 80);
195 1 EXPECT_EQ(term->height, 24);
196 1 EXPECT_EQ(term->ncv_attributes, 0);
197 1 EXPECT_EQ(term->features, TFLAG_8_COLOR);
198 1 EXPECT_EQ(term->ibuf.len, 0);
199 1 EXPECT_NONNULL(term->ibuf.buf);
200
201 // Make sure no terminal output was buffered
202 1 const TermOutputBuffer *obuf = &term->obuf;
203 1 EXPECT_NONNULL(obuf->buf);
204 1 EXPECT_EQ(obuf->count, 0);
205 1 EXPECT_EQ(obuf->scroll_x, 0);
206 1 EXPECT_EQ(obuf->x, 0);
207 1 EXPECT_EQ(obuf->width, 0);
208 1 EXPECT_EQ(obuf->style.fg, COLOR_DEFAULT);
209 1 EXPECT_EQ(obuf->style.bg, COLOR_DEFAULT);
210 1 EXPECT_EQ(obuf->style.attr, 0);
211 1 EXPECT_EQ(obuf->cursor_style.type, CURSOR_DEFAULT);
212 1 EXPECT_EQ(obuf->cursor_style.color, COLOR_DEFAULT);
213
214 1 ASSERT_NONNULL(e->view);
215 1 ASSERT_NONNULL(e->buffer);
216 1 EXPECT_EQ(e->buffers.count, 1);
217 1 EXPECT_NULL(e->buffer->abs_filename);
218 1 EXPECT_PTREQ(e->buffer, e->buffers.ptrs[0]);
219 1 EXPECT_FALSE(e->err.print_to_stderr);
220 1 EXPECT_FALSE(e->err.stderr_errors_printed);
221 1 EXPECT_EQ(e->flags, EFLAG_HEADLESS);
222 1 EXPECT_EQ(e->include_recursion_count, 0);
223 1 EXPECT_FALSE(e->options.lock_files);
224
225 1 frame_remove(e, e->root_frame);
226 1 EXPECT_NULL(e->view);
227 1 EXPECT_NULL(e->buffer);
228 1 EXPECT_EQ(e->buffers.count, 0);
229
230 1 free_editor_state(e);
231 1 EXPECT_EQ(child_controls_terminal, 0);
232 1 EXPECT_TRUE(log_close());
233 1 }
234
235 static const TestEntry itests[] = {
236 TEST(test_process_sanity),
237 TEST(test_posix_sanity),
238 TEST(test_log_open_errors),
239 TEST(test_trace_flags_from_str),
240 TEST(test_init),
241 };
242
243 static const TestEntry dtests[] = {
244 TEST(test_deinit),
245 };
246
247 const TestGroup init_tests = TEST_GROUP(itests);
248 const TestGroup deinit_tests = TEST_GROUP(dtests);
249