Branch data Line data Source code
1 : : /* SPDX-License-Identifier: LGPL-2.1+ */
2 : :
3 : : #include <errno.h>
4 : : #include <locale.h>
5 : : #include <math.h>
6 : : #include <sys/socket.h>
7 : :
8 : : #include "alloc-util.h"
9 : : #include "errno-list.h"
10 : : #include "log.h"
11 : : #include "parse-util.h"
12 : : #include "string-util.h"
13 : :
14 : 4 : static void test_parse_boolean(void) {
15 [ - + ]: 4 : assert_se(parse_boolean("1") == 1);
16 [ - + ]: 4 : assert_se(parse_boolean("y") == 1);
17 [ - + ]: 4 : assert_se(parse_boolean("Y") == 1);
18 [ - + ]: 4 : assert_se(parse_boolean("yes") == 1);
19 [ - + ]: 4 : assert_se(parse_boolean("YES") == 1);
20 [ - + ]: 4 : assert_se(parse_boolean("true") == 1);
21 [ - + ]: 4 : assert_se(parse_boolean("TRUE") == 1);
22 [ - + ]: 4 : assert_se(parse_boolean("on") == 1);
23 [ - + ]: 4 : assert_se(parse_boolean("ON") == 1);
24 : :
25 [ - + ]: 4 : assert_se(parse_boolean("0") == 0);
26 [ - + ]: 4 : assert_se(parse_boolean("n") == 0);
27 [ - + ]: 4 : assert_se(parse_boolean("N") == 0);
28 [ - + ]: 4 : assert_se(parse_boolean("no") == 0);
29 [ - + ]: 4 : assert_se(parse_boolean("NO") == 0);
30 [ - + ]: 4 : assert_se(parse_boolean("false") == 0);
31 [ - + ]: 4 : assert_se(parse_boolean("FALSE") == 0);
32 [ - + ]: 4 : assert_se(parse_boolean("off") == 0);
33 [ - + ]: 4 : assert_se(parse_boolean("OFF") == 0);
34 : :
35 [ - + ]: 4 : assert_se(parse_boolean("garbage") < 0);
36 [ - + ]: 4 : assert_se(parse_boolean("") < 0);
37 [ - + ]: 4 : assert_se(parse_boolean("full") < 0);
38 : 4 : }
39 : :
40 : 4 : static void test_parse_pid(void) {
41 : : int r;
42 : : pid_t pid;
43 : :
44 : 4 : r = parse_pid("100", &pid);
45 [ - + ]: 4 : assert_se(r == 0);
46 [ - + ]: 4 : assert_se(pid == 100);
47 : :
48 : 4 : r = parse_pid("0x7FFFFFFF", &pid);
49 [ - + ]: 4 : assert_se(r == 0);
50 [ - + ]: 4 : assert_se(pid == 2147483647);
51 : :
52 : 4 : pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
53 : 4 : r = parse_pid("0", &pid);
54 [ - + ]: 4 : assert_se(r == -ERANGE);
55 [ - + ]: 4 : assert_se(pid == 65);
56 : :
57 : 4 : pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
58 : 4 : r = parse_pid("-100", &pid);
59 [ - + ]: 4 : assert_se(r == -ERANGE);
60 [ - + ]: 4 : assert_se(pid == 65);
61 : :
62 : 4 : pid = 65; /* pid is left unchanged on ERANGE. Set to known arbitrary value. */
63 : 4 : r = parse_pid("0xFFFFFFFFFFFFFFFFF", &pid);
64 [ - + ]: 4 : assert_se(r == -ERANGE);
65 [ - + ]: 4 : assert_se(pid == 65);
66 : :
67 : 4 : r = parse_pid("junk", &pid);
68 [ - + ]: 4 : assert_se(r == -EINVAL);
69 : :
70 : 4 : r = parse_pid("", &pid);
71 [ - + ]: 4 : assert_se(r == -EINVAL);
72 : 4 : }
73 : :
74 : 4 : static void test_parse_mode(void) {
75 : : mode_t m;
76 : :
77 [ - + ]: 4 : assert_se(parse_mode("-1", &m) < 0);
78 [ - + ]: 4 : assert_se(parse_mode("", &m) < 0);
79 [ - + ]: 4 : assert_se(parse_mode("888", &m) < 0);
80 [ - + ]: 4 : assert_se(parse_mode("77777", &m) < 0);
81 : :
82 [ + - - + ]: 4 : assert_se(parse_mode("544", &m) >= 0 && m == 0544);
83 [ + - - + ]: 4 : assert_se(parse_mode("777", &m) >= 0 && m == 0777);
84 [ + - - + ]: 4 : assert_se(parse_mode("7777", &m) >= 0 && m == 07777);
85 [ + - - + ]: 4 : assert_se(parse_mode("0", &m) >= 0 && m == 0);
86 : 4 : }
87 : :
88 : 4 : static void test_parse_size(void) {
89 : : uint64_t bytes;
90 : :
91 [ - + ]: 4 : assert_se(parse_size("", 1024, &bytes) == -EINVAL);
92 : :
93 [ - + ]: 4 : assert_se(parse_size("111", 1024, &bytes) == 0);
94 [ - + ]: 4 : assert_se(bytes == 111);
95 : :
96 [ - + ]: 4 : assert_se(parse_size("111.4", 1024, &bytes) == 0);
97 [ - + ]: 4 : assert_se(bytes == 111);
98 : :
99 [ - + ]: 4 : assert_se(parse_size(" 112 B", 1024, &bytes) == 0);
100 [ - + ]: 4 : assert_se(bytes == 112);
101 : :
102 [ - + ]: 4 : assert_se(parse_size(" 112.6 B", 1024, &bytes) == 0);
103 [ - + ]: 4 : assert_se(bytes == 112);
104 : :
105 [ - + ]: 4 : assert_se(parse_size("3.5 K", 1024, &bytes) == 0);
106 [ - + ]: 4 : assert_se(bytes == 3*1024 + 512);
107 : :
108 [ - + ]: 4 : assert_se(parse_size("3. K", 1024, &bytes) == 0);
109 [ - + ]: 4 : assert_se(bytes == 3*1024);
110 : :
111 [ - + ]: 4 : assert_se(parse_size("3.0 K", 1024, &bytes) == 0);
112 [ - + ]: 4 : assert_se(bytes == 3*1024);
113 : :
114 [ - + ]: 4 : assert_se(parse_size("3. 0 K", 1024, &bytes) == -EINVAL);
115 : :
116 [ - + ]: 4 : assert_se(parse_size(" 4 M 11.5K", 1024, &bytes) == 0);
117 [ - + ]: 4 : assert_se(bytes == 4*1024*1024 + 11 * 1024 + 512);
118 : :
119 [ - + ]: 4 : assert_se(parse_size("3B3.5G", 1024, &bytes) == -EINVAL);
120 : :
121 [ - + ]: 4 : assert_se(parse_size("3.5G3B", 1024, &bytes) == 0);
122 [ - + ]: 4 : assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 3);
123 : :
124 [ - + ]: 4 : assert_se(parse_size("3.5G 4B", 1024, &bytes) == 0);
125 [ - + ]: 4 : assert_se(bytes == 3ULL*1024*1024*1024 + 512*1024*1024 + 4);
126 : :
127 [ - + ]: 4 : assert_se(parse_size("3B3G4T", 1024, &bytes) == -EINVAL);
128 : :
129 [ - + ]: 4 : assert_se(parse_size("4T3G3B", 1024, &bytes) == 0);
130 [ - + ]: 4 : assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
131 : :
132 [ - + ]: 4 : assert_se(parse_size(" 4 T 3 G 3 B", 1024, &bytes) == 0);
133 [ - + ]: 4 : assert_se(bytes == (4ULL*1024 + 3)*1024*1024*1024 + 3);
134 : :
135 [ - + ]: 4 : assert_se(parse_size("12P", 1024, &bytes) == 0);
136 [ - + ]: 4 : assert_se(bytes == 12ULL * 1024*1024*1024*1024*1024);
137 : :
138 [ - + ]: 4 : assert_se(parse_size("12P12P", 1024, &bytes) == -EINVAL);
139 : :
140 [ - + ]: 4 : assert_se(parse_size("3E 2P", 1024, &bytes) == 0);
141 [ - + ]: 4 : assert_se(bytes == (3 * 1024 + 2ULL) * 1024*1024*1024*1024*1024);
142 : :
143 [ - + ]: 4 : assert_se(parse_size("12X", 1024, &bytes) == -EINVAL);
144 : :
145 [ - + ]: 4 : assert_se(parse_size("12.5X", 1024, &bytes) == -EINVAL);
146 : :
147 [ - + ]: 4 : assert_se(parse_size("12.5e3", 1024, &bytes) == -EINVAL);
148 : :
149 [ - + ]: 4 : assert_se(parse_size("1024E", 1024, &bytes) == -ERANGE);
150 [ - + ]: 4 : assert_se(parse_size("-1", 1024, &bytes) == -ERANGE);
151 [ - + ]: 4 : assert_se(parse_size("-1024E", 1024, &bytes) == -ERANGE);
152 : :
153 [ - + ]: 4 : assert_se(parse_size("-1024P", 1024, &bytes) == -ERANGE);
154 : :
155 [ - + ]: 4 : assert_se(parse_size("-10B 20K", 1024, &bytes) == -ERANGE);
156 : 4 : }
157 : :
158 : 4 : static void test_parse_range(void) {
159 : : unsigned lower, upper;
160 : :
161 : : /* Successful cases */
162 [ - + ]: 4 : assert_se(parse_range("111", &lower, &upper) == 0);
163 [ - + ]: 4 : assert_se(lower == 111);
164 [ - + ]: 4 : assert_se(upper == 111);
165 : :
166 [ - + ]: 4 : assert_se(parse_range("111-123", &lower, &upper) == 0);
167 [ - + ]: 4 : assert_se(lower == 111);
168 [ - + ]: 4 : assert_se(upper == 123);
169 : :
170 [ - + ]: 4 : assert_se(parse_range("123-111", &lower, &upper) == 0);
171 [ - + ]: 4 : assert_se(lower == 123);
172 [ - + ]: 4 : assert_se(upper == 111);
173 : :
174 [ - + ]: 4 : assert_se(parse_range("123-123", &lower, &upper) == 0);
175 [ - + ]: 4 : assert_se(lower == 123);
176 [ - + ]: 4 : assert_se(upper == 123);
177 : :
178 [ - + ]: 4 : assert_se(parse_range("0", &lower, &upper) == 0);
179 [ - + ]: 4 : assert_se(lower == 0);
180 [ - + ]: 4 : assert_se(upper == 0);
181 : :
182 [ - + ]: 4 : assert_se(parse_range("0-15", &lower, &upper) == 0);
183 [ - + ]: 4 : assert_se(lower == 0);
184 [ - + ]: 4 : assert_se(upper == 15);
185 : :
186 [ - + ]: 4 : assert_se(parse_range("15-0", &lower, &upper) == 0);
187 [ - + ]: 4 : assert_se(lower == 15);
188 [ - + ]: 4 : assert_se(upper == 0);
189 : :
190 [ - + ]: 4 : assert_se(parse_range("128-65535", &lower, &upper) == 0);
191 [ - + ]: 4 : assert_se(lower == 128);
192 [ - + ]: 4 : assert_se(upper == 65535);
193 : :
194 [ - + ]: 4 : assert_se(parse_range("1024-4294967295", &lower, &upper) == 0);
195 [ - + ]: 4 : assert_se(lower == 1024);
196 [ - + ]: 4 : assert_se(upper == 4294967295);
197 : :
198 : : /* Leading whitespace is acceptable */
199 [ - + ]: 4 : assert_se(parse_range(" 111", &lower, &upper) == 0);
200 [ - + ]: 4 : assert_se(lower == 111);
201 [ - + ]: 4 : assert_se(upper == 111);
202 : :
203 [ - + ]: 4 : assert_se(parse_range(" 111-123", &lower, &upper) == 0);
204 [ - + ]: 4 : assert_se(lower == 111);
205 [ - + ]: 4 : assert_se(upper == 123);
206 : :
207 [ - + ]: 4 : assert_se(parse_range("111- 123", &lower, &upper) == 0);
208 [ - + ]: 4 : assert_se(lower == 111);
209 [ - + ]: 4 : assert_se(upper == 123);
210 : :
211 [ - + ]: 4 : assert_se(parse_range("\t111-\t123", &lower, &upper) == 0);
212 [ - + ]: 4 : assert_se(lower == 111);
213 [ - + ]: 4 : assert_se(upper == 123);
214 : :
215 [ - + ]: 4 : assert_se(parse_range(" \t 111- \t 123", &lower, &upper) == 0);
216 [ - + ]: 4 : assert_se(lower == 111);
217 [ - + ]: 4 : assert_se(upper == 123);
218 : :
219 : : /* Error cases, make sure they fail as expected */
220 : 4 : lower = upper = 9999;
221 [ - + ]: 4 : assert_se(parse_range("111garbage", &lower, &upper) == -EINVAL);
222 [ - + ]: 4 : assert_se(lower == 9999);
223 [ - + ]: 4 : assert_se(upper == 9999);
224 : :
225 [ - + ]: 4 : assert_se(parse_range("garbage111", &lower, &upper) == -EINVAL);
226 [ - + ]: 4 : assert_se(lower == 9999);
227 [ - + ]: 4 : assert_se(upper == 9999);
228 : :
229 [ - + ]: 4 : assert_se(parse_range("garbage", &lower, &upper) == -EINVAL);
230 [ - + ]: 4 : assert_se(lower == 9999);
231 [ - + ]: 4 : assert_se(upper == 9999);
232 : :
233 [ - + ]: 4 : assert_se(parse_range("111-123garbage", &lower, &upper) == -EINVAL);
234 [ - + ]: 4 : assert_se(lower == 9999);
235 [ - + ]: 4 : assert_se(upper == 9999);
236 : :
237 [ - + ]: 4 : assert_se(parse_range("111garbage-123", &lower, &upper) == -EINVAL);
238 [ - + ]: 4 : assert_se(lower == 9999);
239 [ - + ]: 4 : assert_se(upper == 9999);
240 : :
241 : : /* Empty string */
242 : 4 : lower = upper = 9999;
243 [ - + ]: 4 : assert_se(parse_range("", &lower, &upper) == -EINVAL);
244 [ - + ]: 4 : assert_se(lower == 9999);
245 [ - + ]: 4 : assert_se(upper == 9999);
246 : :
247 : : /* 111--123 will pass -123 to safe_atou which returns -ERANGE for negative */
248 [ - + ]: 4 : assert_se(parse_range("111--123", &lower, &upper) == -ERANGE);
249 [ - + ]: 4 : assert_se(lower == 9999);
250 [ - + ]: 4 : assert_se(upper == 9999);
251 : :
252 [ - + ]: 4 : assert_se(parse_range("-123", &lower, &upper) == -EINVAL);
253 [ - + ]: 4 : assert_se(lower == 9999);
254 [ - + ]: 4 : assert_se(upper == 9999);
255 : :
256 [ - + ]: 4 : assert_se(parse_range("-111-123", &lower, &upper) == -EINVAL);
257 [ - + ]: 4 : assert_se(lower == 9999);
258 [ - + ]: 4 : assert_se(upper == 9999);
259 : :
260 [ - + ]: 4 : assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
261 [ - + ]: 4 : assert_se(lower == 9999);
262 [ - + ]: 4 : assert_se(upper == 9999);
263 : :
264 [ - + ]: 4 : assert_se(parse_range("111.4-123", &lower, &upper) == -EINVAL);
265 [ - + ]: 4 : assert_se(lower == 9999);
266 [ - + ]: 4 : assert_se(upper == 9999);
267 : :
268 [ - + ]: 4 : assert_se(parse_range("111-123.4", &lower, &upper) == -EINVAL);
269 [ - + ]: 4 : assert_se(lower == 9999);
270 [ - + ]: 4 : assert_se(upper == 9999);
271 : :
272 [ - + ]: 4 : assert_se(parse_range("111,4-123", &lower, &upper) == -EINVAL);
273 [ - + ]: 4 : assert_se(lower == 9999);
274 [ - + ]: 4 : assert_se(upper == 9999);
275 : :
276 [ - + ]: 4 : assert_se(parse_range("111-123,4", &lower, &upper) == -EINVAL);
277 [ - + ]: 4 : assert_se(lower == 9999);
278 [ - + ]: 4 : assert_se(upper == 9999);
279 : :
280 : : /* Error on trailing dash */
281 [ - + ]: 4 : assert_se(parse_range("111-", &lower, &upper) == -EINVAL);
282 [ - + ]: 4 : assert_se(lower == 9999);
283 [ - + ]: 4 : assert_se(upper == 9999);
284 : :
285 [ - + ]: 4 : assert_se(parse_range("111-123-", &lower, &upper) == -EINVAL);
286 [ - + ]: 4 : assert_se(lower == 9999);
287 [ - + ]: 4 : assert_se(upper == 9999);
288 : :
289 [ - + ]: 4 : assert_se(parse_range("111--", &lower, &upper) == -EINVAL);
290 [ - + ]: 4 : assert_se(lower == 9999);
291 [ - + ]: 4 : assert_se(upper == 9999);
292 : :
293 [ - + ]: 4 : assert_se(parse_range("111- ", &lower, &upper) == -EINVAL);
294 [ - + ]: 4 : assert_se(lower == 9999);
295 [ - + ]: 4 : assert_se(upper == 9999);
296 : :
297 : : /* Whitespace is not a separator */
298 [ - + ]: 4 : assert_se(parse_range("111 123", &lower, &upper) == -EINVAL);
299 [ - + ]: 4 : assert_se(lower == 9999);
300 [ - + ]: 4 : assert_se(upper == 9999);
301 : :
302 [ - + ]: 4 : assert_se(parse_range("111\t123", &lower, &upper) == -EINVAL);
303 [ - + ]: 4 : assert_se(lower == 9999);
304 [ - + ]: 4 : assert_se(upper == 9999);
305 : :
306 [ - + ]: 4 : assert_se(parse_range("111 \t 123", &lower, &upper) == -EINVAL);
307 [ - + ]: 4 : assert_se(lower == 9999);
308 [ - + ]: 4 : assert_se(upper == 9999);
309 : :
310 : : /* Trailing whitespace is invalid (from safe_atou) */
311 [ - + ]: 4 : assert_se(parse_range("111 ", &lower, &upper) == -EINVAL);
312 [ - + ]: 4 : assert_se(lower == 9999);
313 [ - + ]: 4 : assert_se(upper == 9999);
314 : :
315 [ - + ]: 4 : assert_se(parse_range("111-123 ", &lower, &upper) == -EINVAL);
316 [ - + ]: 4 : assert_se(lower == 9999);
317 [ - + ]: 4 : assert_se(upper == 9999);
318 : :
319 [ - + ]: 4 : assert_se(parse_range("111 -123", &lower, &upper) == -EINVAL);
320 [ - + ]: 4 : assert_se(lower == 9999);
321 [ - + ]: 4 : assert_se(upper == 9999);
322 : :
323 [ - + ]: 4 : assert_se(parse_range("111 -123 ", &lower, &upper) == -EINVAL);
324 [ - + ]: 4 : assert_se(lower == 9999);
325 [ - + ]: 4 : assert_se(upper == 9999);
326 : :
327 [ - + ]: 4 : assert_se(parse_range("111\t-123\t", &lower, &upper) == -EINVAL);
328 [ - + ]: 4 : assert_se(lower == 9999);
329 [ - + ]: 4 : assert_se(upper == 9999);
330 : :
331 [ - + ]: 4 : assert_se(parse_range("111 \t -123 \t ", &lower, &upper) == -EINVAL);
332 [ - + ]: 4 : assert_se(lower == 9999);
333 [ - + ]: 4 : assert_se(upper == 9999);
334 : :
335 : : /* Out of the "unsigned" range, this is 1<<64 */
336 [ - + ]: 4 : assert_se(parse_range("0-18446744073709551616", &lower, &upper) == -ERANGE);
337 [ - + ]: 4 : assert_se(lower == 9999);
338 [ - + ]: 4 : assert_se(upper == 9999);
339 : 4 : }
340 : :
341 : 4 : static void test_safe_atolli(void) {
342 : : int r;
343 : : long long l;
344 : :
345 : 4 : r = safe_atolli("12345", &l);
346 [ - + ]: 4 : assert_se(r == 0);
347 [ - + ]: 4 : assert_se(l == 12345);
348 : :
349 : 4 : r = safe_atolli(" 12345", &l);
350 [ - + ]: 4 : assert_se(r == 0);
351 [ - + ]: 4 : assert_se(l == 12345);
352 : :
353 : 4 : r = safe_atolli("-12345", &l);
354 [ - + ]: 4 : assert_se(r == 0);
355 [ - + ]: 4 : assert_se(l == -12345);
356 : :
357 : 4 : r = safe_atolli(" -12345", &l);
358 [ - + ]: 4 : assert_se(r == 0);
359 [ - + ]: 4 : assert_se(l == -12345);
360 : :
361 : 4 : r = safe_atolli("12345678901234567890", &l);
362 [ - + ]: 4 : assert_se(r == -ERANGE);
363 : :
364 : 4 : r = safe_atolli("-12345678901234567890", &l);
365 [ - + ]: 4 : assert_se(r == -ERANGE);
366 : :
367 : 4 : r = safe_atolli("junk", &l);
368 [ - + ]: 4 : assert_se(r == -EINVAL);
369 : :
370 : 4 : r = safe_atolli("123x", &l);
371 [ - + ]: 4 : assert_se(r == -EINVAL);
372 : :
373 : 4 : r = safe_atolli("12.3", &l);
374 [ - + ]: 4 : assert_se(r == -EINVAL);
375 : :
376 : 4 : r = safe_atolli("", &l);
377 [ - + ]: 4 : assert_se(r == -EINVAL);
378 : 4 : }
379 : :
380 : 4 : static void test_safe_atou16(void) {
381 : : int r;
382 : : uint16_t l;
383 : :
384 : 4 : r = safe_atou16("12345", &l);
385 [ - + ]: 4 : assert_se(r == 0);
386 [ - + ]: 4 : assert_se(l == 12345);
387 : :
388 : 4 : r = safe_atou16(" 12345", &l);
389 [ - + ]: 4 : assert_se(r == 0);
390 [ - + ]: 4 : assert_se(l == 12345);
391 : :
392 : 4 : r = safe_atou16("123456", &l);
393 [ - + ]: 4 : assert_se(r == -ERANGE);
394 : :
395 : 4 : r = safe_atou16("-1", &l);
396 [ - + ]: 4 : assert_se(r == -ERANGE);
397 : :
398 : 4 : r = safe_atou16(" -1", &l);
399 [ - + ]: 4 : assert_se(r == -ERANGE);
400 : :
401 : 4 : r = safe_atou16("junk", &l);
402 [ - + ]: 4 : assert_se(r == -EINVAL);
403 : :
404 : 4 : r = safe_atou16("123x", &l);
405 [ - + ]: 4 : assert_se(r == -EINVAL);
406 : :
407 : 4 : r = safe_atou16("12.3", &l);
408 [ - + ]: 4 : assert_se(r == -EINVAL);
409 : :
410 : 4 : r = safe_atou16("", &l);
411 [ - + ]: 4 : assert_se(r == -EINVAL);
412 : 4 : }
413 : :
414 : 4 : static void test_safe_atoi16(void) {
415 : : int r;
416 : : int16_t l;
417 : :
418 : 4 : r = safe_atoi16("-12345", &l);
419 [ - + ]: 4 : assert_se(r == 0);
420 [ - + ]: 4 : assert_se(l == -12345);
421 : :
422 : 4 : r = safe_atoi16(" -12345", &l);
423 [ - + ]: 4 : assert_se(r == 0);
424 [ - + ]: 4 : assert_se(l == -12345);
425 : :
426 : 4 : r = safe_atoi16("32767", &l);
427 [ - + ]: 4 : assert_se(r == 0);
428 [ - + ]: 4 : assert_se(l == 32767);
429 : :
430 : 4 : r = safe_atoi16(" 32767", &l);
431 [ - + ]: 4 : assert_se(r == 0);
432 [ - + ]: 4 : assert_se(l == 32767);
433 : :
434 : 4 : r = safe_atoi16("36536", &l);
435 [ - + ]: 4 : assert_se(r == -ERANGE);
436 : :
437 : 4 : r = safe_atoi16("-32769", &l);
438 [ - + ]: 4 : assert_se(r == -ERANGE);
439 : :
440 : 4 : r = safe_atoi16("junk", &l);
441 [ - + ]: 4 : assert_se(r == -EINVAL);
442 : :
443 : 4 : r = safe_atoi16("123x", &l);
444 [ - + ]: 4 : assert_se(r == -EINVAL);
445 : :
446 : 4 : r = safe_atoi16("12.3", &l);
447 [ - + ]: 4 : assert_se(r == -EINVAL);
448 : :
449 : 4 : r = safe_atoi16("", &l);
450 [ - + ]: 4 : assert_se(r == -EINVAL);
451 : 4 : }
452 : :
453 : 4 : static void test_safe_atoux16(void) {
454 : : int r;
455 : : uint16_t l;
456 : :
457 : 4 : r = safe_atoux16("1234", &l);
458 [ - + ]: 4 : assert_se(r == 0);
459 [ - + ]: 4 : assert_se(l == 0x1234);
460 : :
461 : 4 : r = safe_atoux16("abcd", &l);
462 [ - + ]: 4 : assert_se(r == 0);
463 [ - + ]: 4 : assert_se(l == 0xabcd);
464 : :
465 : 4 : r = safe_atoux16(" 1234", &l);
466 [ - + ]: 4 : assert_se(r == 0);
467 [ - + ]: 4 : assert_se(l == 0x1234);
468 : :
469 : 4 : r = safe_atoux16("12345", &l);
470 [ - + ]: 4 : assert_se(r == -ERANGE);
471 : :
472 : 4 : r = safe_atoux16("-1", &l);
473 [ - + ]: 4 : assert_se(r == -ERANGE);
474 : :
475 : 4 : r = safe_atoux16(" -1", &l);
476 [ - + ]: 4 : assert_se(r == -ERANGE);
477 : :
478 : 4 : r = safe_atoux16("junk", &l);
479 [ - + ]: 4 : assert_se(r == -EINVAL);
480 : :
481 : 4 : r = safe_atoux16("123x", &l);
482 [ - + ]: 4 : assert_se(r == -EINVAL);
483 : :
484 : 4 : r = safe_atoux16("12.3", &l);
485 [ - + ]: 4 : assert_se(r == -EINVAL);
486 : :
487 : 4 : r = safe_atoux16("", &l);
488 [ - + ]: 4 : assert_se(r == -EINVAL);
489 : 4 : }
490 : :
491 : 4 : static void test_safe_atou64(void) {
492 : : int r;
493 : : uint64_t l;
494 : :
495 : 4 : r = safe_atou64("12345", &l);
496 [ - + ]: 4 : assert_se(r == 0);
497 [ - + ]: 4 : assert_se(l == 12345);
498 : :
499 : 4 : r = safe_atou64(" 12345", &l);
500 [ - + ]: 4 : assert_se(r == 0);
501 [ - + ]: 4 : assert_se(l == 12345);
502 : :
503 : 4 : r = safe_atou64("18446744073709551617", &l);
504 [ - + ]: 4 : assert_se(r == -ERANGE);
505 : :
506 : 4 : r = safe_atou64("-1", &l);
507 [ - + ]: 4 : assert_se(r == -ERANGE);
508 : :
509 : 4 : r = safe_atou64(" -1", &l);
510 [ - + ]: 4 : assert_se(r == -ERANGE);
511 : :
512 : 4 : r = safe_atou64("junk", &l);
513 [ - + ]: 4 : assert_se(r == -EINVAL);
514 : :
515 : 4 : r = safe_atou64("123x", &l);
516 [ - + ]: 4 : assert_se(r == -EINVAL);
517 : :
518 : 4 : r = safe_atou64("12.3", &l);
519 [ - + ]: 4 : assert_se(r == -EINVAL);
520 : :
521 : 4 : r = safe_atou64("", &l);
522 [ - + ]: 4 : assert_se(r == -EINVAL);
523 : 4 : }
524 : :
525 : 4 : static void test_safe_atoi64(void) {
526 : : int r;
527 : : int64_t l;
528 : :
529 : 4 : r = safe_atoi64("-12345", &l);
530 [ - + ]: 4 : assert_se(r == 0);
531 [ - + ]: 4 : assert_se(l == -12345);
532 : :
533 : 4 : r = safe_atoi64(" -12345", &l);
534 [ - + ]: 4 : assert_se(r == 0);
535 [ - + ]: 4 : assert_se(l == -12345);
536 : :
537 : 4 : r = safe_atoi64("32767", &l);
538 [ - + ]: 4 : assert_se(r == 0);
539 [ - + ]: 4 : assert_se(l == 32767);
540 : :
541 : 4 : r = safe_atoi64(" 32767", &l);
542 [ - + ]: 4 : assert_se(r == 0);
543 [ - + ]: 4 : assert_se(l == 32767);
544 : :
545 : 4 : r = safe_atoi64("9223372036854775813", &l);
546 [ - + ]: 4 : assert_se(r == -ERANGE);
547 : :
548 : 4 : r = safe_atoi64("-9223372036854775813", &l);
549 [ - + ]: 4 : assert_se(r == -ERANGE);
550 : :
551 : 4 : r = safe_atoi64("junk", &l);
552 [ - + ]: 4 : assert_se(r == -EINVAL);
553 : :
554 : 4 : r = safe_atoi64("123x", &l);
555 [ - + ]: 4 : assert_se(r == -EINVAL);
556 : :
557 : 4 : r = safe_atoi64("12.3", &l);
558 [ - + ]: 4 : assert_se(r == -EINVAL);
559 : :
560 : 4 : r = safe_atoi64("", &l);
561 [ - + ]: 4 : assert_se(r == -EINVAL);
562 : 4 : }
563 : :
564 : 4 : static void test_safe_atod(void) {
565 : : int r;
566 : : double d;
567 : : char *e;
568 : :
569 : 4 : r = safe_atod("junk", &d);
570 [ - + ]: 4 : assert_se(r == -EINVAL);
571 : :
572 : 4 : r = safe_atod("0.2244", &d);
573 [ - + ]: 4 : assert_se(r == 0);
574 [ - + ]: 4 : assert_se(fabs(d - 0.2244) < 0.000001);
575 : :
576 : 4 : r = safe_atod("0,5", &d);
577 [ - + ]: 4 : assert_se(r == -EINVAL);
578 : :
579 : 4 : errno = 0;
580 : 4 : strtod("0,5", &e);
581 [ - + ]: 4 : assert_se(*e == ',');
582 : :
583 : 4 : r = safe_atod("", &d);
584 [ - + ]: 4 : assert_se(r == -EINVAL);
585 : :
586 : : /* Check if this really is locale independent */
587 [ + - ]: 4 : if (setlocale(LC_NUMERIC, "de_DE.utf8")) {
588 : :
589 : 4 : r = safe_atod("0.2244", &d);
590 [ - + ]: 4 : assert_se(r == 0);
591 [ - + ]: 4 : assert_se(fabs(d - 0.2244) < 0.000001);
592 : :
593 : 4 : r = safe_atod("0,5", &d);
594 [ - + ]: 4 : assert_se(r == -EINVAL);
595 : :
596 : 4 : errno = 0;
597 [ - + ]: 4 : assert_se(fabs(strtod("0,5", &e) - 0.5) < 0.00001);
598 : :
599 : 4 : r = safe_atod("", &d);
600 [ - + ]: 4 : assert_se(r == -EINVAL);
601 : : }
602 : :
603 : : /* And check again, reset */
604 [ - + ]: 4 : assert_se(setlocale(LC_NUMERIC, "C"));
605 : :
606 : 4 : r = safe_atod("0.2244", &d);
607 [ - + ]: 4 : assert_se(r == 0);
608 [ - + ]: 4 : assert_se(fabs(d - 0.2244) < 0.000001);
609 : :
610 : 4 : r = safe_atod("0,5", &d);
611 [ - + ]: 4 : assert_se(r == -EINVAL);
612 : :
613 : 4 : errno = 0;
614 : 4 : strtod("0,5", &e);
615 [ - + ]: 4 : assert_se(*e == ',');
616 : :
617 : 4 : r = safe_atod("", &d);
618 [ - + ]: 4 : assert_se(r == -EINVAL);
619 : 4 : }
620 : :
621 : 4 : static void test_parse_percent(void) {
622 [ - + ]: 4 : assert_se(parse_percent("") == -EINVAL);
623 [ - + ]: 4 : assert_se(parse_percent("foo") == -EINVAL);
624 [ - + ]: 4 : assert_se(parse_percent("0") == -EINVAL);
625 [ - + ]: 4 : assert_se(parse_percent("50") == -EINVAL);
626 [ - + ]: 4 : assert_se(parse_percent("100") == -EINVAL);
627 [ - + ]: 4 : assert_se(parse_percent("-1") == -EINVAL);
628 [ - + ]: 4 : assert_se(parse_percent("0%") == 0);
629 [ - + ]: 4 : assert_se(parse_percent("55%") == 55);
630 [ - + ]: 4 : assert_se(parse_percent("100%") == 100);
631 [ - + ]: 4 : assert_se(parse_percent("-7%") == -ERANGE);
632 [ - + ]: 4 : assert_se(parse_percent("107%") == -ERANGE);
633 [ - + ]: 4 : assert_se(parse_percent("%") == -EINVAL);
634 [ - + ]: 4 : assert_se(parse_percent("%%") == -EINVAL);
635 [ - + ]: 4 : assert_se(parse_percent("%1") == -EINVAL);
636 [ - + ]: 4 : assert_se(parse_percent("1%%") == -EINVAL);
637 [ - + ]: 4 : assert_se(parse_percent("3.2%") == -EINVAL);
638 : 4 : }
639 : :
640 : 4 : static void test_parse_percent_unbounded(void) {
641 [ - + ]: 4 : assert_se(parse_percent_unbounded("101%") == 101);
642 [ - + ]: 4 : assert_se(parse_percent_unbounded("400%") == 400);
643 : 4 : }
644 : :
645 : 4 : static void test_parse_permille(void) {
646 [ - + ]: 4 : assert_se(parse_permille("") == -EINVAL);
647 [ - + ]: 4 : assert_se(parse_permille("foo") == -EINVAL);
648 [ - + ]: 4 : assert_se(parse_permille("0") == -EINVAL);
649 [ - + ]: 4 : assert_se(parse_permille("50") == -EINVAL);
650 [ - + ]: 4 : assert_se(parse_permille("100") == -EINVAL);
651 [ - + ]: 4 : assert_se(parse_permille("-1") == -EINVAL);
652 : :
653 [ - + ]: 4 : assert_se(parse_permille("0‰") == 0);
654 [ - + ]: 4 : assert_se(parse_permille("555‰") == 555);
655 [ - + ]: 4 : assert_se(parse_permille("1000‰") == 1000);
656 [ - + ]: 4 : assert_se(parse_permille("-7‰") == -ERANGE);
657 [ - + ]: 4 : assert_se(parse_permille("1007‰") == -ERANGE);
658 [ - + ]: 4 : assert_se(parse_permille("‰") == -EINVAL);
659 [ - + ]: 4 : assert_se(parse_permille("‰‰") == -EINVAL);
660 [ - + ]: 4 : assert_se(parse_permille("‰1") == -EINVAL);
661 [ - + ]: 4 : assert_se(parse_permille("1‰‰") == -EINVAL);
662 [ - + ]: 4 : assert_se(parse_permille("3.2‰") == -EINVAL);
663 : :
664 [ - + ]: 4 : assert_se(parse_permille("0%") == 0);
665 [ - + ]: 4 : assert_se(parse_permille("55%") == 550);
666 [ - + ]: 4 : assert_se(parse_permille("55.5%") == 555);
667 [ - + ]: 4 : assert_se(parse_permille("100%") == 1000);
668 [ - + ]: 4 : assert_se(parse_permille("-7%") == -ERANGE);
669 [ - + ]: 4 : assert_se(parse_permille("107%") == -ERANGE);
670 [ - + ]: 4 : assert_se(parse_permille("%") == -EINVAL);
671 [ - + ]: 4 : assert_se(parse_permille("%%") == -EINVAL);
672 [ - + ]: 4 : assert_se(parse_permille("%1") == -EINVAL);
673 [ - + ]: 4 : assert_se(parse_permille("1%%") == -EINVAL);
674 [ - + ]: 4 : assert_se(parse_permille("3.21%") == -EINVAL);
675 : 4 : }
676 : :
677 : 4 : static void test_parse_permille_unbounded(void) {
678 [ - + ]: 4 : assert_se(parse_permille_unbounded("1001‰") == 1001);
679 [ - + ]: 4 : assert_se(parse_permille_unbounded("4000‰") == 4000);
680 [ - + ]: 4 : assert_se(parse_permille_unbounded("2147483647‰") == 2147483647);
681 [ - + ]: 4 : assert_se(parse_permille_unbounded("2147483648‰") == -ERANGE);
682 [ - + ]: 4 : assert_se(parse_permille_unbounded("4294967295‰") == -ERANGE);
683 [ - + ]: 4 : assert_se(parse_permille_unbounded("4294967296‰") == -ERANGE);
684 : :
685 [ - + ]: 4 : assert_se(parse_permille_unbounded("101%") == 1010);
686 [ - + ]: 4 : assert_se(parse_permille_unbounded("400%") == 4000);
687 [ - + ]: 4 : assert_se(parse_permille_unbounded("214748364.7%") == 2147483647);
688 [ - + ]: 4 : assert_se(parse_permille_unbounded("214748364.8%") == -ERANGE);
689 [ - + ]: 4 : assert_se(parse_permille_unbounded("429496729.5%") == -ERANGE);
690 [ - + ]: 4 : assert_se(parse_permille_unbounded("429496729.6%") == -ERANGE);
691 : 4 : }
692 : :
693 : 4 : static void test_parse_nice(void) {
694 : : int n;
695 : :
696 [ + - - + ]: 4 : assert_se(parse_nice("0", &n) >= 0 && n == 0);
697 [ + - - + ]: 4 : assert_se(parse_nice("+0", &n) >= 0 && n == 0);
698 [ + - - + ]: 4 : assert_se(parse_nice("-1", &n) >= 0 && n == -1);
699 [ + - - + ]: 4 : assert_se(parse_nice("-2", &n) >= 0 && n == -2);
700 [ + - - + ]: 4 : assert_se(parse_nice("1", &n) >= 0 && n == 1);
701 [ + - - + ]: 4 : assert_se(parse_nice("2", &n) >= 0 && n == 2);
702 [ + - - + ]: 4 : assert_se(parse_nice("+1", &n) >= 0 && n == 1);
703 [ + - - + ]: 4 : assert_se(parse_nice("+2", &n) >= 0 && n == 2);
704 [ + - - + ]: 4 : assert_se(parse_nice("-20", &n) >= 0 && n == -20);
705 [ + - - + ]: 4 : assert_se(parse_nice("19", &n) >= 0 && n == 19);
706 [ + - - + ]: 4 : assert_se(parse_nice("+19", &n) >= 0 && n == 19);
707 : :
708 [ - + ]: 4 : assert_se(parse_nice("", &n) == -EINVAL);
709 [ - + ]: 4 : assert_se(parse_nice("-", &n) == -EINVAL);
710 [ - + ]: 4 : assert_se(parse_nice("+", &n) == -EINVAL);
711 [ - + ]: 4 : assert_se(parse_nice("xx", &n) == -EINVAL);
712 [ - + ]: 4 : assert_se(parse_nice("-50", &n) == -ERANGE);
713 [ - + ]: 4 : assert_se(parse_nice("50", &n) == -ERANGE);
714 [ - + ]: 4 : assert_se(parse_nice("+50", &n) == -ERANGE);
715 [ - + ]: 4 : assert_se(parse_nice("-21", &n) == -ERANGE);
716 [ - + ]: 4 : assert_se(parse_nice("20", &n) == -ERANGE);
717 [ - + ]: 4 : assert_se(parse_nice("+20", &n) == -ERANGE);
718 : 4 : }
719 : :
720 : 4 : static void test_parse_dev(void) {
721 : : dev_t dev;
722 : :
723 [ - + ]: 4 : assert_se(parse_dev("", &dev) == -EINVAL);
724 [ - + ]: 4 : assert_se(parse_dev("junk", &dev) == -EINVAL);
725 [ - + ]: 4 : assert_se(parse_dev("0", &dev) == -EINVAL);
726 [ - + ]: 4 : assert_se(parse_dev("5", &dev) == -EINVAL);
727 [ - + ]: 4 : assert_se(parse_dev("5:", &dev) == -EINVAL);
728 [ - + ]: 4 : assert_se(parse_dev(":5", &dev) == -EINVAL);
729 [ - + ]: 4 : assert_se(parse_dev("-1:-1", &dev) == -EINVAL);
730 : : #if SIZEOF_DEV_T < 8
731 : : assert_se(parse_dev("4294967295:4294967295", &dev) == -EINVAL);
732 : : #endif
733 [ + - - + : 4 : assert_se(parse_dev("8:11", &dev) >= 0 && major(dev) == 8 && minor(dev) == 11);
+ - - + ]
734 [ + - - + : 4 : assert_se(parse_dev("0:0", &dev) >= 0 && major(dev) == 0 && minor(dev) == 0);
+ - - + ]
735 : 4 : }
736 : :
737 : 4 : static void test_parse_errno(void) {
738 [ - + ]: 4 : assert_se(parse_errno("EILSEQ") == EILSEQ);
739 [ - + ]: 4 : assert_se(parse_errno("EINVAL") == EINVAL);
740 [ - + ]: 4 : assert_se(parse_errno("0") == 0);
741 [ - + ]: 4 : assert_se(parse_errno("1") == 1);
742 [ - + ]: 4 : assert_se(parse_errno("4095") == 4095);
743 : :
744 [ - + ]: 4 : assert_se(parse_errno("-1") == -ERANGE);
745 [ - + ]: 4 : assert_se(parse_errno("-3") == -ERANGE);
746 [ - + ]: 4 : assert_se(parse_errno("4096") == -ERANGE);
747 : :
748 [ - + ]: 4 : assert_se(parse_errno("") == -EINVAL);
749 [ - + ]: 4 : assert_se(parse_errno("12.3") == -EINVAL);
750 [ - + ]: 4 : assert_se(parse_errno("123junk") == -EINVAL);
751 [ - + ]: 4 : assert_se(parse_errno("junk123") == -EINVAL);
752 [ - + ]: 4 : assert_se(parse_errno("255EILSEQ") == -EINVAL);
753 [ - + ]: 4 : assert_se(parse_errno("EINVAL12") == -EINVAL);
754 [ - + ]: 4 : assert_se(parse_errno("-EINVAL") == -EINVAL);
755 [ - + ]: 4 : assert_se(parse_errno("EINVALaaa") == -EINVAL);
756 : 4 : }
757 : :
758 : 4 : static void test_parse_syscall_and_errno(void) {
759 : 4 : _cleanup_free_ char *n = NULL;
760 : : int e;
761 : :
762 [ - + ]: 4 : assert_se(parse_syscall_and_errno("uname:EILSEQ", &n, &e) >= 0);
763 [ - + ]: 4 : assert_se(streq(n, "uname"));
764 [ + - - + ]: 4 : assert_se(e == errno_from_name("EILSEQ") && e >= 0);
765 : 4 : n = mfree(n);
766 : :
767 [ - + ]: 4 : assert_se(parse_syscall_and_errno("uname:EINVAL", &n, &e) >= 0);
768 [ - + ]: 4 : assert_se(streq(n, "uname"));
769 [ + - - + ]: 4 : assert_se(e == errno_from_name("EINVAL") && e >= 0);
770 : 4 : n = mfree(n);
771 : :
772 [ - + ]: 4 : assert_se(parse_syscall_and_errno("@sync:4095", &n, &e) >= 0);
773 [ - + ]: 4 : assert_se(streq(n, "@sync"));
774 [ - + ]: 4 : assert_se(e == 4095);
775 : 4 : n = mfree(n);
776 : :
777 : : /* If errno is omitted, then e is set to -1 */
778 [ - + ]: 4 : assert_se(parse_syscall_and_errno("mount", &n, &e) >= 0);
779 [ - + ]: 4 : assert_se(streq(n, "mount"));
780 [ - + ]: 4 : assert_se(e == -1);
781 : 4 : n = mfree(n);
782 : :
783 : : /* parse_syscall_and_errno() does not check the syscall name is valid or not. */
784 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:255", &n, &e) >= 0);
785 [ - + ]: 4 : assert_se(streq(n, "hoge"));
786 [ - + ]: 4 : assert_se(e == 255);
787 : 4 : n = mfree(n);
788 : :
789 : : /* The function checks the syscall name is empty or not. */
790 [ - + ]: 4 : assert_se(parse_syscall_and_errno("", &n, &e) == -EINVAL);
791 [ - + ]: 4 : assert_se(parse_syscall_and_errno(":255", &n, &e) == -EINVAL);
792 : :
793 : : /* errno must be a valid errno name or number between 0 and ERRNO_MAX == 4095 */
794 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:4096", &n, &e) == -ERANGE);
795 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:-3", &n, &e) == -ERANGE);
796 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:12.3", &n, &e) == -EINVAL);
797 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:123junk", &n, &e) == -EINVAL);
798 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:junk123", &n, &e) == -EINVAL);
799 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:255:EILSEQ", &n, &e) == -EINVAL);
800 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:-EINVAL", &n, &e) == -EINVAL);
801 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:EINVALaaa", &n, &e) == -EINVAL);
802 [ - + ]: 4 : assert_se(parse_syscall_and_errno("hoge:", &n, &e) == -EINVAL);
803 : 4 : }
804 : :
805 : 4 : static void test_parse_mtu(void) {
806 : 4 : uint32_t mtu = 0;
807 : :
808 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "1500", &mtu) >= 0 && mtu == 1500);
809 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "1400", &mtu) >= 0 && mtu == 1400);
810 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "65535", &mtu) >= 0 && mtu == 65535);
811 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "65536", &mtu) >= 0 && mtu == 65536);
812 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "4294967295", &mtu) >= 0 && mtu == 4294967295);
813 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "500", &mtu) >= 0 && mtu == 500);
814 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "1280", &mtu) >= 0 && mtu == 1280);
815 [ + - - + ]: 4 : assert_se(parse_mtu(AF_INET6, "1280", &mtu) >= 0 && mtu == 1280);
816 [ - + ]: 4 : assert_se(parse_mtu(AF_INET6, "1279", &mtu) == -ERANGE);
817 [ - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "4294967296", &mtu) == -ERANGE);
818 [ - + ]: 4 : assert_se(parse_mtu(AF_INET6, "4294967296", &mtu) == -ERANGE);
819 [ - + ]: 4 : assert_se(parse_mtu(AF_INET6, "68", &mtu) == -ERANGE);
820 [ + - - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "68", &mtu) >= 0 && mtu == 68);
821 [ - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "67", &mtu) == -ERANGE);
822 [ - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "0", &mtu) == -ERANGE);
823 [ - + ]: 4 : assert_se(parse_mtu(AF_UNSPEC, "", &mtu) == -EINVAL);
824 : 4 : }
825 : :
826 : 4 : int main(int argc, char *argv[]) {
827 : 4 : log_parse_environment();
828 : 4 : log_open();
829 : :
830 : 4 : test_parse_boolean();
831 : 4 : test_parse_pid();
832 : 4 : test_parse_mode();
833 : 4 : test_parse_size();
834 : 4 : test_parse_range();
835 : 4 : test_safe_atolli();
836 : 4 : test_safe_atou16();
837 : 4 : test_safe_atoi16();
838 : 4 : test_safe_atoux16();
839 : 4 : test_safe_atou64();
840 : 4 : test_safe_atoi64();
841 : 4 : test_safe_atod();
842 : 4 : test_parse_percent();
843 : 4 : test_parse_percent_unbounded();
844 : 4 : test_parse_permille();
845 : 4 : test_parse_permille_unbounded();
846 : 4 : test_parse_nice();
847 : 4 : test_parse_dev();
848 : 4 : test_parse_errno();
849 : 4 : test_parse_syscall_and_errno();
850 : 4 : test_parse_mtu();
851 : :
852 : 4 : return 0;
853 : : }
|
