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 : 5 : SPDK_LOG_REGISTER_COMPONENT(log)
18 : :
19 : : static void
20 : 5 : log_test(void)
21 : : {
22 : 5 : spdk_log_set_level(SPDK_LOG_ERROR);
23 : 5 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_ERROR);
24 : 5 : spdk_log_set_level(SPDK_LOG_WARN);
25 : 5 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_WARN);
26 : 5 : spdk_log_set_level(SPDK_LOG_NOTICE);
27 : 5 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_NOTICE);
28 : 5 : spdk_log_set_level(SPDK_LOG_INFO);
29 : 5 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_INFO);
30 : 5 : spdk_log_set_level(SPDK_LOG_DEBUG);
31 : 5 : CU_ASSERT_EQUAL(spdk_log_get_level(), SPDK_LOG_DEBUG);
32 : :
33 : 5 : spdk_log_set_print_level(SPDK_LOG_ERROR);
34 : 5 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_ERROR);
35 : 5 : spdk_log_set_print_level(SPDK_LOG_WARN);
36 : 5 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_WARN);
37 : 5 : spdk_log_set_print_level(SPDK_LOG_NOTICE);
38 : 5 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_NOTICE);
39 : 5 : spdk_log_set_print_level(SPDK_LOG_INFO);
40 : 5 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_INFO);
41 : 5 : spdk_log_set_print_level(SPDK_LOG_DEBUG);
42 : 5 : CU_ASSERT_EQUAL(spdk_log_get_print_level(), SPDK_LOG_DEBUG);
43 : :
44 : : #ifdef DEBUG
45 : 5 : CU_ASSERT(spdk_log_get_flag("LOG") == false);
46 : :
47 : 5 : spdk_log_set_flag("log");
48 : 5 : CU_ASSERT(spdk_log_get_flag("LOG") == true);
49 : :
50 : 5 : spdk_log_clear_flag("LOG");
51 : 5 : CU_ASSERT(spdk_log_get_flag("LOG") == false);
52 : : #endif
53 : :
54 : 5 : spdk_log_open(NULL);
55 : 5 : spdk_log_set_flag("log");
56 : 5 : SPDK_WARNLOG("log warning unit test\n");
57 [ + + + - ]: 5 : SPDK_DEBUGLOG(log, "log test\n");
58 [ + + + - ]: 5 : SPDK_LOGDUMP(log, "log dump test:", "log dump", 8);
59 : 5 : 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 : 5 : spdk_log_dump(stderr, "spdk dump test:", "spdk dump 16 more chars", 23);
62 : :
63 : 5 : spdk_log_close();
64 : 5 : }
65 : :
66 [ - + ]: 5 : SPDK_LOG_DEPRECATION_REGISTER(unit_test_not_limited, "not rate limited", "never", 0)
67 [ - + ]: 5 : SPDK_LOG_DEPRECATION_REGISTER(unit_test_limited, "with rate limit", "sometime", 1)
68 [ - + ]: 5 : 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 : 25 : 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 : 25 : g_ut_dep_log_times++;
83 : :
84 : 25 : CU_ASSERT(level == SPDK_LOG_WARN);
85 : :
86 [ + + + + ]: 25 : if (strcmp("spdk_log_deprecated", func) == 0) {
87 : 5 : g_ut_dep_saw_suppressed_log = true;
88 : : } else {
89 [ - + - + ]: 20 : CU_ASSERT(strcmp(g_ut_dep_expect_func, func) == 0);
90 : 20 : CU_ASSERT(g_ut_dep_expect_line == line);
91 : : }
92 : :
93 : : /* A "starts with" check */
94 : 25 : msg = spdk_vsprintf_alloc(format, args);
95 [ - + ]: 25 : SPDK_CU_ASSERT_FATAL(msg != NULL);
96 [ - + - + : 25 : CU_ASSERT(strncmp(g_ut_dep_expect_msg, msg, strlen(g_ut_dep_expect_msg)) == 0)
- + ]
97 : :
98 : 25 : free(msg);
99 : 25 : }
100 : :
101 : : bool g_found_not_limited;
102 : : bool g_found_limited;
103 : : bool g_found_never_called;
104 : :
105 : : static int
106 : 15 : iter_dep_cb(void *ctx, struct spdk_deprecation *dep)
107 : : {
108 : : /* The getters work from the callback. */
109 [ + + ]: 15 : if (dep == _deprecated_unit_test_not_limited) {
110 [ - + ]: 5 : CU_ASSERT(!g_found_not_limited);
111 : 5 : g_found_not_limited = true;
112 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_tag(dep), "unit_test_not_limited") == 0);
113 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_description(dep), "not rate limited") == 0);
114 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_remove_release(dep), "never") == 0);
115 : 5 : CU_ASSERT(spdk_deprecation_get_hits(dep) != 0);
116 [ + + ]: 10 : } else if (dep == _deprecated_unit_test_limited) {
117 [ - + ]: 5 : CU_ASSERT(!g_found_limited);
118 : 5 : g_found_limited = true;
119 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_tag(dep), "unit_test_limited") == 0);
120 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_description(dep), "with rate limit") == 0);
121 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_remove_release(dep), "sometime") == 0);
122 : 5 : CU_ASSERT(spdk_deprecation_get_hits(dep) != 0);
123 [ + - ]: 5 : } else if (dep == _deprecated_unit_test_never_called) {
124 [ - + ]: 5 : CU_ASSERT(!g_found_never_called);
125 : 5 : g_found_never_called = true;
126 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_tag(dep), "unit_test_never_called") == 0);
127 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_description(dep), "not called") == 0);
128 [ - + ]: 5 : CU_ASSERT(strcmp(spdk_deprecation_get_remove_release(dep), "maybe") == 0);
129 : 5 : CU_ASSERT(spdk_deprecation_get_hits(dep) == 0);
130 : : } else {
131 : 0 : CU_ASSERT(false);
132 : : }
133 : :
134 : 15 : return 0;
135 : : }
136 : :
137 : : static void
138 : 5 : deprecation(void)
139 : : {
140 : : int rc;
141 : :
142 : 5 : spdk_log_open(log_deprecations);
143 : :
144 : : /* A log message is emitted for every message without rate limiting. */
145 : 5 : g_ut_dep_saw_suppressed_log = false;
146 : 5 : g_ut_dep_log_times = 0;
147 : 5 : g_ut_dep_expect_func = __func__;
148 : 5 : g_ut_dep_expect_msg = "unit_test_not_limited:";
149 : 5 : g_ut_dep_expect_line = __LINE__ + 1;
150 : 5 : SPDK_LOG_DEPRECATED(unit_test_not_limited);
151 : 5 : CU_ASSERT(_deprecated_unit_test_not_limited->hits == 1);
152 : 5 : CU_ASSERT(_deprecated_unit_test_not_limited->deferred == 0);
153 : 5 : CU_ASSERT(g_ut_dep_log_times == 1);
154 : 5 : g_ut_dep_expect_line = __LINE__ + 1;
155 : 5 : SPDK_LOG_DEPRECATED(unit_test_not_limited);
156 : 5 : CU_ASSERT(_deprecated_unit_test_not_limited->hits == 2);
157 : 5 : CU_ASSERT(_deprecated_unit_test_not_limited->deferred == 0);
158 : 5 : CU_ASSERT(g_ut_dep_log_times == 2);
159 [ - + ]: 5 : CU_ASSERT(!g_ut_dep_saw_suppressed_log);
160 : :
161 : : /* Rate limiting keeps track of deferred messages */
162 : 5 : g_ut_dep_saw_suppressed_log = false;
163 : 5 : g_ut_dep_log_times = 0;
164 : 5 : g_ut_dep_expect_msg = "unit_test_limited:";
165 : 5 : g_ut_dep_expect_line = __LINE__ + 1;
166 : 5 : SPDK_LOG_DEPRECATED(unit_test_limited);
167 : 5 : CU_ASSERT(_deprecated_unit_test_limited->hits == 1);
168 : 5 : CU_ASSERT(_deprecated_unit_test_limited->deferred == 0);
169 : 5 : CU_ASSERT(g_ut_dep_log_times == 1);
170 : 5 : SPDK_LOG_DEPRECATED(unit_test_limited);
171 : 5 : CU_ASSERT(_deprecated_unit_test_limited->hits == 2);
172 : 5 : CU_ASSERT(_deprecated_unit_test_limited->deferred == 1);
173 : 5 : CU_ASSERT(g_ut_dep_log_times == 1);
174 [ - + ]: 5 : 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 : 5 : g_ut_dep_saw_suppressed_log = false;
180 : 5 : sleep(1);
181 : 5 : g_ut_dep_expect_line = __LINE__ + 1;
182 : 5 : SPDK_LOG_DEPRECATED(unit_test_limited);
183 : 5 : CU_ASSERT(_deprecated_unit_test_limited->hits == 3);
184 : 5 : CU_ASSERT(_deprecated_unit_test_limited->deferred == 0);
185 : 5 : CU_ASSERT(g_ut_dep_log_times == 3);
186 [ - + ]: 5 : CU_ASSERT(g_ut_dep_saw_suppressed_log);
187 : :
188 : : /* spdk_log_for_each_deprecation() visits each registered deprecation */
189 : 5 : rc = spdk_log_for_each_deprecation(NULL, iter_dep_cb);
190 : 5 : CU_ASSERT(rc == 0);
191 [ - + ]: 5 : CU_ASSERT(g_found_not_limited);
192 [ - + ]: 5 : CU_ASSERT(g_found_limited);
193 [ - + ]: 5 : CU_ASSERT(g_found_never_called);
194 : :
195 : 5 : g_log = NULL;
196 : 5 : }
197 : :
198 : : int
199 : 5 : main(int argc, char **argv)
200 : : {
201 : 5 : CU_pSuite suite = NULL;
202 : : unsigned int num_failures;
203 : :
204 : 5 : CU_initialize_registry();
205 : :
206 : 5 : suite = CU_add_suite("log", NULL, NULL);
207 : :
208 : 5 : CU_ADD_TEST(suite, log_test);
209 : 5 : CU_ADD_TEST(suite, deprecation);
210 : :
211 : 5 : num_failures = spdk_ut_run_tests(argc, argv, NULL);
212 : 5 : CU_cleanup_registry();
213 : 5 : return num_failures;
214 : : }
|