1 /*
2 * utils module tests
3 * Copyright (c) 2014, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9 #include "utils/includes.h"
10
11 #include "utils/common.h"
12 #include "utils/bitfield.h"
13 #include "utils/ext_password.h"
14 #include "utils/trace.h"
15
16
17 struct printf_test_data {
18 u8 *data;
19 size_t len;
20 char *encoded;
21 };
22
23 static const struct printf_test_data printf_tests[] = {
24 { (u8 *) "abcde", 5, "abcde" },
25 { (u8 *) "a\0b\nc\ed\re\tf\"\\", 13, "a\\0b\\nc\\ed\\re\\tf\\\"\\\\" },
26 { (u8 *) "\x00\x31\x00\x32\x00\x39", 6, "\\x001\\0002\\09" },
27 { (u8 *) "\n\n\n", 3, "\n\12\x0a" },
28 { (u8 *) "\303\245\303\244\303\266\303\205\303\204\303\226", 12,
29 "\\xc3\\xa5\xc3\\xa4\\xc3\\xb6\\xc3\\x85\\xc3\\x84\\xc3\\x96" },
30 { (u8 *) "\303\245\303\244\303\266\303\205\303\204\303\226", 12,
31 "\\303\\245\\303\\244\\303\\266\\303\\205\\303\\204\\303\\226" },
32 { (u8 *) "\xe5\xe4\xf6\xc5\xc4\xd6", 6,
33 "\\xe5\\xe4\\xf6\\xc5\\xc4\\xd6" },
34 { NULL, 0, NULL }
35 };
36
37
printf_encode_decode_tests(void)38 static int printf_encode_decode_tests(void)
39 {
40 int i;
41 size_t binlen;
42 char buf[100];
43 u8 bin[100];
44 int errors = 0;
45
46 wpa_printf(MSG_INFO, "printf encode/decode tests");
47
48 for (i = 0; printf_tests[i].data; i++) {
49 const struct printf_test_data *test = &printf_tests[i];
50 printf_encode(buf, sizeof(buf), test->data, test->len);
51 wpa_printf(MSG_INFO, "%d: -> \"%s\"", i, buf);
52
53 binlen = printf_decode(bin, sizeof(bin), buf);
54 if (binlen != test->len ||
55 os_memcmp(bin, test->data, binlen) != 0) {
56 wpa_hexdump(MSG_ERROR, "Error in decoding#1",
57 bin, binlen);
58 errors++;
59 }
60
61 binlen = printf_decode(bin, sizeof(bin), test->encoded);
62 if (binlen != test->len ||
63 os_memcmp(bin, test->data, binlen) != 0) {
64 wpa_hexdump(MSG_ERROR, "Error in decoding#2",
65 bin, binlen);
66 errors++;
67 }
68 }
69
70 buf[5] = 'A';
71 printf_encode(buf, 5, (const u8 *) "abcde", 5);
72 if (buf[5] != 'A') {
73 wpa_printf(MSG_ERROR, "Error in bounds checking#1");
74 errors++;
75 }
76
77 for (i = 5; i < 10; i++) {
78 buf[i] = 'A';
79 printf_encode(buf, i, (const u8 *) "\xdd\xdd\xdd\xdd\xdd", 5);
80 if (buf[i] != 'A') {
81 wpa_printf(MSG_ERROR, "Error in bounds checking#2(%d)",
82 i);
83 errors++;
84 }
85 }
86
87 if (errors) {
88 wpa_printf(MSG_ERROR, "%d printf test(s) failed", errors);
89 return -1;
90 }
91
92 return 0;
93 }
94
95
bitfield_tests(void)96 static int bitfield_tests(void)
97 {
98 struct bitfield *bf;
99 int i;
100 int errors = 0;
101
102 wpa_printf(MSG_INFO, "bitfield tests");
103
104 bf = bitfield_alloc(123);
105 if (bf == NULL)
106 return -1;
107
108 for (i = 0; i < 123; i++) {
109 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
110 errors++;
111 if (i > 0 && bitfield_is_set(bf, i - 1))
112 errors++;
113 bitfield_set(bf, i);
114 if (!bitfield_is_set(bf, i))
115 errors++;
116 bitfield_clear(bf, i);
117 if (bitfield_is_set(bf, i))
118 errors++;
119 }
120
121 for (i = 123; i < 200; i++) {
122 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
123 errors++;
124 if (i > 0 && bitfield_is_set(bf, i - 1))
125 errors++;
126 bitfield_set(bf, i);
127 if (bitfield_is_set(bf, i))
128 errors++;
129 bitfield_clear(bf, i);
130 if (bitfield_is_set(bf, i))
131 errors++;
132 }
133
134 for (i = 0; i < 123; i++) {
135 if (bitfield_is_set(bf, i) || bitfield_is_set(bf, i + 1))
136 errors++;
137 bitfield_set(bf, i);
138 if (!bitfield_is_set(bf, i))
139 errors++;
140 }
141
142 for (i = 0; i < 123; i++) {
143 if (!bitfield_is_set(bf, i))
144 errors++;
145 bitfield_clear(bf, i);
146 if (bitfield_is_set(bf, i))
147 errors++;
148 }
149
150 for (i = 0; i < 123; i++) {
151 if (bitfield_get_first_zero(bf) != i)
152 errors++;
153 bitfield_set(bf, i);
154 }
155 if (bitfield_get_first_zero(bf) != -1)
156 errors++;
157 for (i = 0; i < 123; i++) {
158 if (!bitfield_is_set(bf, i))
159 errors++;
160 bitfield_clear(bf, i);
161 if (bitfield_get_first_zero(bf) != i)
162 errors++;
163 bitfield_set(bf, i);
164 }
165 if (bitfield_get_first_zero(bf) != -1)
166 errors++;
167
168 bitfield_free(bf);
169
170 if (errors) {
171 wpa_printf(MSG_ERROR, "%d bitfield test(s) failed", errors);
172 return -1;
173 }
174
175 return 0;
176 }
177
178
int_array_tests(void)179 static int int_array_tests(void)
180 {
181 int test1[] = { 1, 2, 3, 4, 5, 6, 0 };
182 int test2[] = { 1, -1, 0 };
183 int test3[] = { 1, 1, 1, -1, 2, 3, 4, 1, 2, 0 };
184 int test3_res[] = { -1, 1, 2, 3, 4, 0 };
185 int errors = 0;
186 int len;
187
188 wpa_printf(MSG_INFO, "int_array tests");
189
190 if (int_array_len(test1) != 6 ||
191 int_array_len(test2) != 2)
192 errors++;
193
194 int_array_sort_unique(test3);
195 len = int_array_len(test3_res);
196 if (int_array_len(test3) != len)
197 errors++;
198 else if (os_memcmp(test3, test3_res, len * sizeof(int)) != 0)
199 errors++;
200
201 if (errors) {
202 wpa_printf(MSG_ERROR, "%d int_array test(s) failed", errors);
203 return -1;
204 }
205
206 return 0;
207 }
208
209
ext_password_tests(void)210 static int ext_password_tests(void)
211 {
212 struct ext_password_data *data;
213 int ret = 0;
214 struct wpabuf *pw;
215
216 wpa_printf(MSG_INFO, "ext_password tests");
217
218 data = ext_password_init("unknown", "foo");
219 if (data != NULL)
220 return -1;
221
222 data = ext_password_init("test", NULL);
223 if (data == NULL)
224 return -1;
225 pw = ext_password_get(data, "foo");
226 if (pw != NULL)
227 ret = -1;
228 ext_password_free(pw);
229
230 ext_password_deinit(data);
231
232 pw = ext_password_get(NULL, "foo");
233 if (pw != NULL)
234 ret = -1;
235 ext_password_free(pw);
236
237 return ret;
238 }
239
240
trace_tests(void)241 static int trace_tests(void)
242 {
243 wpa_printf(MSG_INFO, "trace tests");
244
245 wpa_trace_show("test backtrace");
246 wpa_trace_dump_funcname("test funcname", trace_tests);
247
248 return 0;
249 }
250
251
utils_module_tests(void)252 int utils_module_tests(void)
253 {
254 int ret = 0;
255
256 wpa_printf(MSG_INFO, "utils module tests");
257
258 if (printf_encode_decode_tests() < 0 ||
259 ext_password_tests() < 0 ||
260 trace_tests() < 0 ||
261 bitfield_tests() < 0 ||
262 int_array_tests() < 0)
263 ret = -1;
264
265 return ret;
266 }
267