1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * Copyright (c) 2020, Heinrich Schuchardt <xypron.glpk@gmx.de>
4 *
5 * Logging function tests for CONFIG_LOG_SYSLOG=y.
6 *
7 * Invoke the test with: ./u-boot -d arch/sandbox/dts/test.dtb
8 */
9
10 /* Override CONFIG_LOG_MAX_LEVEL */
11 #define LOG_DEBUG
12
13 #include <common.h>
14 #include <asm/global_data.h>
15 #include <dm/device.h>
16 #include <hexdump.h>
17 #include <test/log.h>
18 #include <test/test.h>
19 #include <test/suites.h>
20 #include <test/ut.h>
21 #include <asm/eth.h>
22 #include "syslog_test.h"
23
24 DECLARE_GLOBAL_DATA_PTR;
25
sb_log_tx_handler(struct udevice * dev,void * packet,unsigned int len)26 int sb_log_tx_handler(struct udevice *dev, void *packet, unsigned int len)
27 {
28 struct eth_sandbox_priv *priv = dev_get_priv(dev);
29 struct sb_log_env *env = priv->priv;
30 /* uts is updated by the ut_assert* macros */
31 struct unit_test_state *uts = env->uts;
32 char *buf = packet;
33 struct ethernet_hdr *eth_hdr = packet;
34 struct ip_udp_hdr *ip_udp_hdr;
35
36 /* Check Ethernet header */
37 ut_asserteq_mem(ð_hdr->et_dest, net_bcast_ethaddr, ARP_HLEN);
38 ut_asserteq(ntohs(eth_hdr->et_protlen), PROT_IP);
39
40 /* Check IP header */
41 buf += sizeof(struct ethernet_hdr);
42 ip_udp_hdr = (struct ip_udp_hdr *)buf;
43 ut_asserteq(ip_udp_hdr->ip_p, IPPROTO_UDP);
44 ut_asserteq(ip_udp_hdr->ip_dst.s_addr, 0xffffffff);
45 ut_asserteq(ntohs(ip_udp_hdr->udp_dst), 514);
46 ut_asserteq(UDP_HDR_SIZE + strlen(env->expected) + 1,
47 ntohs(ip_udp_hdr->udp_len));
48
49 /* Check payload */
50 buf += sizeof(struct ip_udp_hdr);
51 ut_asserteq_mem(env->expected, buf,
52 ntohs(ip_udp_hdr->udp_len) - UDP_HDR_SIZE);
53
54 /* Signal that the callback function has been executed */
55 env->expected = NULL;
56
57 return 0;
58 }
59
syslog_test_setup(struct unit_test_state * uts)60 int syslog_test_setup(struct unit_test_state *uts)
61 {
62 ut_assertok(log_device_set_enable(LOG_GET_DRIVER(syslog), true));
63
64 return 0;
65 }
66
syslog_test_finish(struct unit_test_state * uts)67 int syslog_test_finish(struct unit_test_state *uts)
68 {
69 ut_assertok(log_device_set_enable(LOG_GET_DRIVER(syslog), false));
70
71 return 0;
72 }
73
74 /**
75 * log_test_syslog_err() - test log_err() function
76 *
77 * @uts: unit test state
78 * Return: 0 = success
79 */
log_test_syslog_err(struct unit_test_state * uts)80 static int log_test_syslog_err(struct unit_test_state *uts)
81 {
82 int old_log_level = gd->default_log_level;
83 struct sb_log_env env;
84
85 ut_assertok(syslog_test_setup(uts));
86 gd->log_fmt = LOGF_TEST;
87 gd->default_log_level = LOGL_INFO;
88 env_set("ethact", "eth@10002000");
89 env_set("log_hostname", "sandbox");
90 env.expected = "<3>sandbox uboot: log_test_syslog_err() "
91 "testing log_err\n";
92 env.uts = uts;
93 sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
94 /* Used by ut_assert macros in the tx_handler */
95 sandbox_eth_set_priv(0, &env);
96 log_err("testing %s\n", "log_err");
97 /* Check that the callback function was called */
98 sandbox_eth_set_tx_handler(0, NULL);
99 gd->default_log_level = old_log_level;
100 gd->log_fmt = log_get_default_format();
101 ut_assertok(syslog_test_finish(uts));
102
103 return 0;
104 }
105 LOG_TEST(log_test_syslog_err);
106
107 /**
108 * log_test_syslog_warning() - test log_warning() function
109 *
110 * @uts: unit test state
111 * Return: 0 = success
112 */
log_test_syslog_warning(struct unit_test_state * uts)113 static int log_test_syslog_warning(struct unit_test_state *uts)
114 {
115 int old_log_level = gd->default_log_level;
116 struct sb_log_env env;
117
118 ut_assertok(syslog_test_setup(uts));
119 gd->log_fmt = LOGF_TEST;
120 gd->default_log_level = LOGL_INFO;
121 env_set("ethact", "eth@10002000");
122 env_set("log_hostname", "sandbox");
123 env.expected = "<4>sandbox uboot: log_test_syslog_warning() "
124 "testing log_warning\n";
125 env.uts = uts;
126 sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
127 /* Used by ut_assert macros in the tx_handler */
128 sandbox_eth_set_priv(0, &env);
129 log_warning("testing %s\n", "log_warning");
130 sandbox_eth_set_tx_handler(0, NULL);
131 /* Check that the callback function was called */
132 ut_assertnull(env.expected);
133 gd->default_log_level = old_log_level;
134 gd->log_fmt = log_get_default_format();
135 ut_assertok(syslog_test_finish(uts));
136
137 return 0;
138 }
139 LOG_TEST(log_test_syslog_warning);
140
141 /**
142 * log_test_syslog_notice() - test log_notice() function
143 *
144 * @uts: unit test state
145 * Return: 0 = success
146 */
log_test_syslog_notice(struct unit_test_state * uts)147 static int log_test_syslog_notice(struct unit_test_state *uts)
148 {
149 int old_log_level = gd->default_log_level;
150 struct sb_log_env env;
151
152 ut_assertok(syslog_test_setup(uts));
153 gd->log_fmt = LOGF_TEST;
154 gd->default_log_level = LOGL_INFO;
155 env_set("ethact", "eth@10002000");
156 env_set("log_hostname", "sandbox");
157 env.expected = "<5>sandbox uboot: log_test_syslog_notice() "
158 "testing log_notice\n";
159 env.uts = uts;
160 sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
161 /* Used by ut_assert macros in the tx_handler */
162 sandbox_eth_set_priv(0, &env);
163 log_notice("testing %s\n", "log_notice");
164 sandbox_eth_set_tx_handler(0, NULL);
165 /* Check that the callback function was called */
166 ut_assertnull(env.expected);
167 gd->default_log_level = old_log_level;
168 gd->log_fmt = log_get_default_format();
169 ut_assertok(syslog_test_finish(uts));
170
171 return 0;
172 }
173 LOG_TEST(log_test_syslog_notice);
174
175 /**
176 * log_test_syslog_info() - test log_info() function
177 *
178 * @uts: unit test state
179 * Return: 0 = success
180 */
log_test_syslog_info(struct unit_test_state * uts)181 static int log_test_syslog_info(struct unit_test_state *uts)
182 {
183 int old_log_level = gd->default_log_level;
184 struct sb_log_env env;
185
186 ut_assertok(syslog_test_setup(uts));
187 gd->log_fmt = LOGF_TEST;
188 gd->default_log_level = LOGL_INFO;
189 env_set("ethact", "eth@10002000");
190 env_set("log_hostname", "sandbox");
191 env.expected = "<6>sandbox uboot: log_test_syslog_info() "
192 "testing log_info\n";
193 env.uts = uts;
194 sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
195 /* Used by ut_assert macros in the tx_handler */
196 sandbox_eth_set_priv(0, &env);
197 log_info("testing %s\n", "log_info");
198 sandbox_eth_set_tx_handler(0, NULL);
199 /* Check that the callback function was called */
200 ut_assertnull(env.expected);
201 gd->default_log_level = old_log_level;
202 gd->log_fmt = log_get_default_format();
203 ut_assertok(syslog_test_finish(uts));
204
205 return 0;
206 }
207 LOG_TEST(log_test_syslog_info);
208
209 /**
210 * log_test_syslog_debug() - test log_debug() function
211 *
212 * @uts: unit test state
213 * Return: 0 = success
214 */
log_test_syslog_debug(struct unit_test_state * uts)215 static int log_test_syslog_debug(struct unit_test_state *uts)
216 {
217 int old_log_level = gd->default_log_level;
218 struct sb_log_env env;
219
220 ut_assertok(syslog_test_setup(uts));
221 gd->log_fmt = LOGF_TEST;
222 gd->default_log_level = LOGL_DEBUG;
223 env_set("ethact", "eth@10002000");
224 env_set("log_hostname", "sandbox");
225 env.expected = "<7>sandbox uboot: log_test_syslog_debug() "
226 "testing log_debug\n";
227 env.uts = uts;
228 sandbox_eth_set_tx_handler(0, sb_log_tx_handler);
229 /* Used by ut_assert macros in the tx_handler */
230 sandbox_eth_set_priv(0, &env);
231 log_debug("testing %s\n", "log_debug");
232 sandbox_eth_set_tx_handler(0, NULL);
233 /* Check that the callback function was called */
234 ut_assertnull(env.expected);
235 gd->default_log_level = old_log_level;
236 gd->log_fmt = log_get_default_format();
237 ut_assertok(syslog_test_finish(uts));
238
239 return 0;
240 }
241 LOG_TEST(log_test_syslog_debug);
242