Branch data Line data Source code
1 : : /* SPDX-License-Identifier: BSD-3-Clause
2 : : * Copyright (C) 2016 Intel Corporation.
3 : : * All rights reserved.
4 : : */
5 : :
6 : : #include "spdk/stdinc.h"
7 : :
8 : : #include "spdk_internal/cunit.h"
9 : : #include "spdk/log.h"
10 : : #include "spdk/env.h"
11 : : #include "spdk/string.h"
12 : :
13 : : #include "log/log.c"
14 : : #include "log/log_flags.c"
15 : : #include "log/log_deprecated.c"
16 : :
17 : 3 : SPDK_LOG_REGISTER_COMPONENT(log)
18 : :
19 : : static void
20 : 3 : log_test(void)
21 : : {
22 : 3 : spdk_log_set_level(SPDK_LOG_ERROR);
23 : 3 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_ERROR);
24 : 3 : spdk_log_set_level(SPDK_LOG_WARN);
25 : 3 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_WARN);
26 : 3 : spdk_log_set_level(SPDK_LOG_NOTICE);
27 : 3 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_NOTICE);
28 : 3 : spdk_log_set_level(SPDK_LOG_INFO);
29 : 3 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_INFO);
30 : 3 : spdk_log_set_level(SPDK_LOG_DEBUG);
31 : 3 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_DEBUG);
32 : :
33 : 3 : spdk_log_set_print_level(SPDK_LOG_ERROR);
34 : 3 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_ERROR);
35 : 3 : spdk_log_set_print_level(SPDK_LOG_WARN);
36 : 3 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_WARN);
37 : 3 : spdk_log_set_print_level(SPDK_LOG_NOTICE);
38 : 3 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_NOTICE);
39 : 3 : spdk_log_set_print_level(SPDK_LOG_INFO);
40 : 3 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_INFO);
41 : 3 : spdk_log_set_print_level(SPDK_LOG_DEBUG);
42 : 3 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_DEBUG);
43 : :
44 : : #ifdef DEBUG
45 : 3 : CU_ASSERT(spdk_log_get_flag("LOG") == false);
46 : :
47 : 3 : spdk_log_set_flag("log");
48 : 3 : CU_ASSERT(spdk_log_get_flag("LOG") == true);
49 : :
50 : 3 : spdk_log_clear_flag("LOG");
51 : 3 : CU_ASSERT(spdk_log_get_flag("LOG") == false);
52 : : #endif
53 : :
54 : 3 : spdk_log_open(NULL);
55 : 3 : spdk_log_set_flag("log");
56 : 3 : SPDK_WARNLOG("log warning unit test\n");
57 [ + + + - ]: 3 : SPDK_DEBUGLOG(log, "log test\n");
58 [ + + + - ]: 3 : SPDK_LOGDUMP(log, "log dump test:", "log dump", 8);
59 : 3 : spdk_log_dump(stderr, "spdk dump test:", "spdk dump", 9);
60 : : /* Test spdk_log_dump with more than 16 chars and less than 32 chars */
61 : 3 : spdk_log_dump(stderr, "spdk dump test:", "spdk dump 16 more chars", 23);
62 : :
63 : 3 : spdk_log_close();
64 : 3 : }
65 : :
66 [ - + ]: 3 : SPDK_LOG_DEPRECATION_REGISTER(unit_test_not_limited, "not rate limited", "never", 0)
67 [ - + ]: 3 : SPDK_LOG_DEPRECATION_REGISTER(unit_test_limited, "with rate limit", "sometime", 1)
68 [ - + ]: 3 : SPDK_LOG_DEPRECATION_REGISTER(unit_test_never_called, "not called", "maybe", 0)
69 : :
70 : : int g_ut_dep_expect_line;
71 : : const char *g_ut_dep_expect_func;
72 : : const char *g_ut_dep_expect_msg;
73 : : uint32_t g_ut_dep_log_times;
74 : : bool g_ut_dep_saw_suppressed_log;
75 : :
76 : : static void
77 : 15 : log_deprecations(int level, const char *file, const int line, const char *func,
78 : : const char *format, va_list args)
79 : : {
80 : : char *msg;
81 : :
82 : 15 : g_ut_dep_log_times++;
83 : :
84 : 15 : CU_ASSERT(level == SPDK_LOG_WARN);
85 : :
86 [ + + + + ]: 15 : if (strcmp("spdk_log_deprecated", func) == 0) {
87 : 3 : g_ut_dep_saw_suppressed_log = true;
88 : : } else {
89 [ - + - + ]: 12 : CU_ASSERT(strcmp(g_ut_dep_expect_func, func) == 0);
90 : 12 : CU_ASSERT(g_ut_dep_expect_line == line);
91 : : }
92 : :
93 : : /* A "starts with" check */
94 : 15 : msg = spdk_vsprintf_alloc(format, args);
95 [ - + ]: 15 : SPDK_CU_ASSERT_FATAL(msg != NULL);
96 [ - + - + : 15 : CU_ASSERT(strncmp(g_ut_dep_expect_msg, msg, strlen(g_ut_dep_expect_msg)) == 0)
- + ]
97 : :
98 : 15 : free(msg);
99 : 15 : }
100 : :
101 : : bool g_found_not_limited;
102 : : bool g_found_limited;
103 : : bool g_found_never_called;
104 : :
105 : : static int
106 : 9 : iter_dep_cb(void *ctx, struct spdk_deprecation *dep)
107 : : {
108 : : /* The getters work from the callback. */
109 [ + + ]: 9 : if (dep == _deprecated_unit_test_not_limited) {
110 [ - + ]: 3 : CU_ASSERT(!g_found_not_limited);
111 : 3 : g_found_not_limited = true;
112 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_tag(dep), "unit_test_not_limited") == 0);
113 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_description(dep), "not rate limited") == 0);
114 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_remove_release(dep), "never") == 0);
115 : 3 : CU_ASSERT(spdk_deprecation_get_hits(dep) != 0);
116 [ + + ]: 6 : } else if (dep == _deprecated_unit_test_limited) {
117 [ - + ]: 3 : CU_ASSERT(!g_found_limited);
118 : 3 : g_found_limited = true;
119 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_tag(dep), "unit_test_limited") == 0);
120 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_description(dep), "with rate limit") == 0);
121 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_remove_release(dep), "sometime") == 0);
122 : 3 : CU_ASSERT(spdk_deprecation_get_hits(dep) != 0);
123 [ + - ]: 3 : } else if (dep == _deprecated_unit_test_never_called) {
124 [ - + ]: 3 : CU_ASSERT(!g_found_never_called);
125 : 3 : g_found_never_called = true;
126 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_tag(dep), "unit_test_never_called") == 0);
127 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_description(dep), "not called") == 0);
128 [ - + ]: 3 : CU_ASSERT(strcmp(spdk_deprecation_get_remove_release(dep), "maybe") == 0);
129 : 3 : CU_ASSERT(spdk_deprecation_get_hits(dep) == 0);
130 : : } else {
131 : 0 : CU_ASSERT(false);
132 : : }
133 : :
134 : 9 : return 0;
135 : : }
136 : :
137 : : static void
138 : 3 : deprecation(void)
139 : : {
140 : : int rc;
141 : :
142 : 3 : spdk_log_open(log_deprecations);
143 : :
144 : : /* A log message is emitted for every message without rate limiting. */
145 : 3 : g_ut_dep_saw_suppressed_log = false;
146 : 3 : g_ut_dep_log_times = 0;
147 : 3 : g_ut_dep_expect_func = __func__;
148 : 3 : g_ut_dep_expect_msg = "unit_test_not_limited:";
149 : 3 : g_ut_dep_expect_line = __LINE__ + 1;
150 : 3 : SPDK_LOG_DEPRECATED(unit_test_not_limited);
151 : 3 : CU_ASSERT(_deprecated_unit_test_not_limited->hits == 1);
152 : 3 : CU_ASSERT(_deprecated_unit_test_not_limited->deferred == 0);
153 : 3 : CU_ASSERT(g_ut_dep_log_times == 1);
154 : 3 : g_ut_dep_expect_line = __LINE__ + 1;
155 : 3 : SPDK_LOG_DEPRECATED(unit_test_not_limited);
156 : 3 : CU_ASSERT(_deprecated_unit_test_not_limited->hits == 2);
157 : 3 : CU_ASSERT(_deprecated_unit_test_not_limited->deferred == 0);
158 : 3 : CU_ASSERT(g_ut_dep_log_times == 2);
159 [ - + ]: 3 : CU_ASSERT(!g_ut_dep_saw_suppressed_log);
160 : :
161 : : /* Rate limiting keeps track of deferred messages */
162 : 3 : g_ut_dep_saw_suppressed_log = false;
163 : 3 : g_ut_dep_log_times = 0;
164 : 3 : g_ut_dep_expect_msg = "unit_test_limited:";
165 : 3 : g_ut_dep_expect_line = __LINE__ + 1;
166 : 3 : SPDK_LOG_DEPRECATED(unit_test_limited);
167 : 3 : CU_ASSERT(_deprecated_unit_test_limited->hits == 1);
168 : 3 : CU_ASSERT(_deprecated_unit_test_limited->deferred == 0);
169 : 3 : CU_ASSERT(g_ut_dep_log_times == 1);
170 : 3 : SPDK_LOG_DEPRECATED(unit_test_limited);
171 : 3 : CU_ASSERT(_deprecated_unit_test_limited->hits == 2);
172 : 3 : CU_ASSERT(_deprecated_unit_test_limited->deferred == 1);
173 : 3 : CU_ASSERT(g_ut_dep_log_times == 1);
174 [ - + ]: 3 : CU_ASSERT(!g_ut_dep_saw_suppressed_log);
175 : :
176 : : /* After a delay, the next log message prints the normal message followed by one that says
177 : : * that some messages were suppressed.
178 : : */
179 : 3 : g_ut_dep_saw_suppressed_log = false;
180 : 3 : sleep(1);
181 : 3 : g_ut_dep_expect_line = __LINE__ + 1;
182 : 3 : SPDK_LOG_DEPRECATED(unit_test_limited);
183 : 3 : CU_ASSERT(_deprecated_unit_test_limited->hits == 3);
184 : 3 : CU_ASSERT(_deprecated_unit_test_limited->deferred == 0);
185 : 3 : CU_ASSERT(g_ut_dep_log_times == 3);
186 [ - + ]: 3 : CU_ASSERT(g_ut_dep_saw_suppressed_log);
187 : :
188 : : /* spdk_log_for_each_deprecation() visits each registered deprecation */
189 : 3 : rc = spdk_log_for_each_deprecation(NULL, iter_dep_cb);
190 : 3 : CU_ASSERT(rc == 0);
191 [ - + ]: 3 : CU_ASSERT(g_found_not_limited);
192 [ - + ]: 3 : CU_ASSERT(g_found_limited);
193 [ - + ]: 3 : CU_ASSERT(g_found_never_called);
194 : :
195 : 3 : spdk_log_close();
196 : 3 : }
197 : :
198 : : enum log_ext_state {
199 : : LOG_EXT_UNUSED,
200 : : LOG_EXT_OPENED,
201 : : LOG_EXT_USED,
202 : : LOG_EXT_CLOSED,
203 : : };
204 : :
205 : : enum log_ext_state g_log_state = LOG_EXT_UNUSED;
206 : :
207 : : static void
208 : 3 : log_ext_log_test(int level, const char *file, const int line, const char *func,
209 : : const char *format, va_list args)
210 : : {
211 : 3 : g_log_state = LOG_EXT_USED;
212 : 3 : }
213 : :
214 : : static void
215 : 3 : log_ext_open_test(void *ctx)
216 : : {
217 : 3 : enum log_ext_state *state = ctx;
218 : :
219 : 3 : *state = LOG_EXT_OPENED;
220 : 3 : }
221 : :
222 : : static void
223 : 3 : log_ext_close_test(void *ctx)
224 : : {
225 : 3 : enum log_ext_state *state = ctx;
226 : :
227 : 3 : *state = LOG_EXT_CLOSED;
228 : 3 : }
229 : :
230 : : static void
231 : 3 : log_ext_test(void)
232 : : {
233 : 3 : struct spdk_log_opts opts = {.log = log_ext_log_test, .open = log_ext_open_test, .close = log_ext_close_test, .user_ctx = &g_log_state};
234 : 3 : opts.size = SPDK_SIZEOF(&opts, user_ctx);
235 : :
236 : 3 : CU_ASSERT(g_log_state == LOG_EXT_UNUSED);
237 : 3 : spdk_log_open_ext(&opts);
238 : 3 : CU_ASSERT(g_log_state == LOG_EXT_OPENED);
239 : 3 : SPDK_WARNLOG("log warning unit test\n");
240 : 3 : CU_ASSERT(g_log_state == LOG_EXT_USED);
241 : 3 : spdk_log_close();
242 : 3 : CU_ASSERT(g_log_state == LOG_EXT_CLOSED);
243 : 3 : }
244 : :
245 : : int
246 : 3 : main(int argc, char **argv)
247 : : {
248 : 3 : CU_pSuite suite = NULL;
249 : : unsigned int num_failures;
250 : :
251 : 3 : CU_initialize_registry();
252 : :
253 : 3 : suite = CU_add_suite("log", NULL, NULL);
254 : :
255 : 3 : CU_ADD_TEST(suite, log_test);
256 : 3 : CU_ADD_TEST(suite, deprecation);
257 : 3 : CU_ADD_TEST(suite, log_ext_test);
258 : :
259 : 3 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
260 : 3 : CU_cleanup_registry();
261 : 3 : return num_failures;
262 : : }
|