1 | #include <linux/init.h> |
2 | #include <linux/kernel.h> |
3 | #include <linux/module.h> |
4 | |
5 | #define for_each_test(i, test) \ |
6 | for (i = 0; i < ARRAY_SIZE(test); i++) |
7 | |
8 | struct test_fail { |
9 | const char *str; |
10 | unsigned int base; |
11 | }; |
12 | |
13 | #define DEFINE_TEST_FAIL(test) \ |
14 | const struct test_fail test[] __initconst |
15 | |
16 | #define DECLARE_TEST_OK(type, test_type) \ |
17 | test_type { \ |
18 | const char *str; \ |
19 | unsigned int base; \ |
20 | type expected_res; \ |
21 | } |
22 | |
23 | #define DEFINE_TEST_OK(type, test) \ |
24 | const type test[] __initconst |
25 | |
26 | #define TEST_FAIL(fn, type, fmt, test) \ |
27 | { \ |
28 | unsigned int i; \ |
29 | \ |
30 | for_each_test(i, test) { \ |
31 | const struct test_fail *t = &test[i]; \ |
32 | type tmp; \ |
33 | int rv; \ |
34 | \ |
35 | tmp = 0; \ |
36 | rv = fn(t->str, t->base, &tmp); \ |
37 | if (rv >= 0) { \ |
38 | WARN(1, "str '%s', base %u, expected -E, got %d/" fmt "\n", \ |
39 | t->str, t->base, rv, tmp); \ |
40 | continue; \ |
41 | } \ |
42 | } \ |
43 | } |
44 | |
45 | #define TEST_OK(fn, type, fmt, test) \ |
46 | { \ |
47 | unsigned int i; \ |
48 | \ |
49 | for_each_test(i, test) { \ |
50 | const typeof(test[0]) *t = &test[i]; \ |
51 | type res; \ |
52 | int rv; \ |
53 | \ |
54 | rv = fn(t->str, t->base, &res); \ |
55 | if (rv != 0) { \ |
56 | WARN(1, "str '%s', base %u, expected 0/" fmt ", got %d\n", \ |
57 | t->str, t->base, t->expected_res, rv); \ |
58 | continue; \ |
59 | } \ |
60 | if (res != t->expected_res) { \ |
61 | WARN(1, "str '%s', base %u, expected " fmt ", got " fmt "\n", \ |
62 | t->str, t->base, t->expected_res, res); \ |
63 | continue; \ |
64 | } \ |
65 | } \ |
66 | } |
67 | |
68 | static void __init test_kstrtoull_ok(void) |
69 | { |
70 | DECLARE_TEST_OK(unsigned long long, struct test_ull); |
71 | static DEFINE_TEST_OK(struct test_ull, test_ull_ok) = { |
72 | {.str: "0" , .base: 10, .expected_res: 0ULL}, |
73 | {"1" , 10, 1ULL}, |
74 | {"127" , 10, 127ULL}, |
75 | {"128" , 10, 128ULL}, |
76 | {"129" , 10, 129ULL}, |
77 | {"255" , 10, 255ULL}, |
78 | {"256" , 10, 256ULL}, |
79 | {"257" , 10, 257ULL}, |
80 | {"32767" , 10, 32767ULL}, |
81 | {"32768" , 10, 32768ULL}, |
82 | {"32769" , 10, 32769ULL}, |
83 | {"65535" , 10, 65535ULL}, |
84 | {"65536" , 10, 65536ULL}, |
85 | {"65537" , 10, 65537ULL}, |
86 | {"2147483647" , 10, 2147483647ULL}, |
87 | {"2147483648" , 10, 2147483648ULL}, |
88 | {"2147483649" , 10, 2147483649ULL}, |
89 | {"4294967295" , 10, 4294967295ULL}, |
90 | {"4294967296" , 10, 4294967296ULL}, |
91 | {"4294967297" , 10, 4294967297ULL}, |
92 | {"9223372036854775807" , 10, 9223372036854775807ULL}, |
93 | {"9223372036854775808" , 10, 9223372036854775808ULL}, |
94 | {"9223372036854775809" , 10, 9223372036854775809ULL}, |
95 | {"18446744073709551614" , 10, 18446744073709551614ULL}, |
96 | {"18446744073709551615" , 10, 18446744073709551615ULL}, |
97 | |
98 | {"00" , 8, 00ULL}, |
99 | {"01" , 8, 01ULL}, |
100 | {"0177" , 8, 0177ULL}, |
101 | {"0200" , 8, 0200ULL}, |
102 | {"0201" , 8, 0201ULL}, |
103 | {"0377" , 8, 0377ULL}, |
104 | {"0400" , 8, 0400ULL}, |
105 | {"0401" , 8, 0401ULL}, |
106 | {"077777" , 8, 077777ULL}, |
107 | {"0100000" , 8, 0100000ULL}, |
108 | {"0100001" , 8, 0100001ULL}, |
109 | {"0177777" , 8, 0177777ULL}, |
110 | {"0200000" , 8, 0200000ULL}, |
111 | {"0200001" , 8, 0200001ULL}, |
112 | {"017777777777" , 8, 017777777777ULL}, |
113 | {"020000000000" , 8, 020000000000ULL}, |
114 | {"020000000001" , 8, 020000000001ULL}, |
115 | {"037777777777" , 8, 037777777777ULL}, |
116 | {"040000000000" , 8, 040000000000ULL}, |
117 | {"040000000001" , 8, 040000000001ULL}, |
118 | {"0777777777777777777777" , 8, 0777777777777777777777ULL}, |
119 | {"01000000000000000000000" , 8, 01000000000000000000000ULL}, |
120 | {"01000000000000000000001" , 8, 01000000000000000000001ULL}, |
121 | {"01777777777777777777776" , 8, 01777777777777777777776ULL}, |
122 | {"01777777777777777777777" , 8, 01777777777777777777777ULL}, |
123 | |
124 | {"0x0" , 16, 0x0ULL}, |
125 | {"0x1" , 16, 0x1ULL}, |
126 | {"0x7f" , 16, 0x7fULL}, |
127 | {"0x80" , 16, 0x80ULL}, |
128 | {"0x81" , 16, 0x81ULL}, |
129 | {"0xff" , 16, 0xffULL}, |
130 | {"0x100" , 16, 0x100ULL}, |
131 | {"0x101" , 16, 0x101ULL}, |
132 | {"0x7fff" , 16, 0x7fffULL}, |
133 | {"0x8000" , 16, 0x8000ULL}, |
134 | {"0x8001" , 16, 0x8001ULL}, |
135 | {"0xffff" , 16, 0xffffULL}, |
136 | {"0x10000" , 16, 0x10000ULL}, |
137 | {"0x10001" , 16, 0x10001ULL}, |
138 | {"0x7fffffff" , 16, 0x7fffffffULL}, |
139 | {"0x80000000" , 16, 0x80000000ULL}, |
140 | {"0x80000001" , 16, 0x80000001ULL}, |
141 | {"0xffffffff" , 16, 0xffffffffULL}, |
142 | {"0x100000000" , 16, 0x100000000ULL}, |
143 | {"0x100000001" , 16, 0x100000001ULL}, |
144 | {"0x7fffffffffffffff" , 16, 0x7fffffffffffffffULL}, |
145 | {"0x8000000000000000" , 16, 0x8000000000000000ULL}, |
146 | {"0x8000000000000001" , 16, 0x8000000000000001ULL}, |
147 | {"0xfffffffffffffffe" , 16, 0xfffffffffffffffeULL}, |
148 | {"0xffffffffffffffff" , 16, 0xffffffffffffffffULL}, |
149 | |
150 | {"0\n" , 0, 0ULL}, |
151 | }; |
152 | TEST_OK(kstrtoull, unsigned long long, "%llu" , test_ull_ok); |
153 | } |
154 | |
155 | static void __init test_kstrtoull_fail(void) |
156 | { |
157 | static DEFINE_TEST_FAIL(test_ull_fail) = { |
158 | {"" , 0}, |
159 | {"" , 8}, |
160 | {"" , 10}, |
161 | {"" , 16}, |
162 | {"\n" , 0}, |
163 | {"\n" , 8}, |
164 | {"\n" , 10}, |
165 | {"\n" , 16}, |
166 | {"\n0" , 0}, |
167 | {"\n0" , 8}, |
168 | {"\n0" , 10}, |
169 | {"\n0" , 16}, |
170 | {"+" , 0}, |
171 | {"+" , 8}, |
172 | {"+" , 10}, |
173 | {"+" , 16}, |
174 | {"-" , 0}, |
175 | {"-" , 8}, |
176 | {"-" , 10}, |
177 | {"-" , 16}, |
178 | {"0x" , 0}, |
179 | {"0x" , 16}, |
180 | {"0X" , 0}, |
181 | {"0X" , 16}, |
182 | {"0 " , 0}, |
183 | {"1+" , 0}, |
184 | {"1-" , 0}, |
185 | {" 2" , 0}, |
186 | /* base autodetection */ |
187 | {"0x0z" , 0}, |
188 | {"0z" , 0}, |
189 | {"a" , 0}, |
190 | /* digit >= base */ |
191 | {"2" , 2}, |
192 | {"8" , 8}, |
193 | {"a" , 10}, |
194 | {"A" , 10}, |
195 | {"g" , 16}, |
196 | {"G" , 16}, |
197 | /* overflow */ |
198 | {"10000000000000000000000000000000000000000000000000000000000000000" , 2}, |
199 | {"2000000000000000000000" , 8}, |
200 | {"18446744073709551616" , 10}, |
201 | {"10000000000000000" , 16}, |
202 | /* negative */ |
203 | {"-0" , 0}, |
204 | {"-0" , 8}, |
205 | {"-0" , 10}, |
206 | {"-0" , 16}, |
207 | {"-1" , 0}, |
208 | {"-1" , 8}, |
209 | {"-1" , 10}, |
210 | {"-1" , 16}, |
211 | /* sign is first character if any */ |
212 | {"-+1" , 0}, |
213 | {"-+1" , 8}, |
214 | {"-+1" , 10}, |
215 | {"-+1" , 16}, |
216 | /* nothing after \n */ |
217 | {"0\n0" , 0}, |
218 | {"0\n0" , 8}, |
219 | {"0\n0" , 10}, |
220 | {"0\n0" , 16}, |
221 | {"0\n+" , 0}, |
222 | {"0\n+" , 8}, |
223 | {"0\n+" , 10}, |
224 | {"0\n+" , 16}, |
225 | {"0\n-" , 0}, |
226 | {"0\n-" , 8}, |
227 | {"0\n-" , 10}, |
228 | {"0\n-" , 16}, |
229 | {"0\n " , 0}, |
230 | {"0\n " , 8}, |
231 | {"0\n " , 10}, |
232 | {"0\n " , 16}, |
233 | }; |
234 | TEST_FAIL(kstrtoull, unsigned long long, "%llu" , test_ull_fail); |
235 | } |
236 | |
237 | static void __init test_kstrtoll_ok(void) |
238 | { |
239 | DECLARE_TEST_OK(long long, struct test_ll); |
240 | static DEFINE_TEST_OK(struct test_ll, test_ll_ok) = { |
241 | {"0" , 10, 0LL}, |
242 | {"1" , 10, 1LL}, |
243 | {"127" , 10, 127LL}, |
244 | {"128" , 10, 128LL}, |
245 | {"129" , 10, 129LL}, |
246 | {"255" , 10, 255LL}, |
247 | {"256" , 10, 256LL}, |
248 | {"257" , 10, 257LL}, |
249 | {"32767" , 10, 32767LL}, |
250 | {"32768" , 10, 32768LL}, |
251 | {"32769" , 10, 32769LL}, |
252 | {"65535" , 10, 65535LL}, |
253 | {"65536" , 10, 65536LL}, |
254 | {"65537" , 10, 65537LL}, |
255 | {"2147483647" , 10, 2147483647LL}, |
256 | {"2147483648" , 10, 2147483648LL}, |
257 | {"2147483649" , 10, 2147483649LL}, |
258 | {"4294967295" , 10, 4294967295LL}, |
259 | {"4294967296" , 10, 4294967296LL}, |
260 | {"4294967297" , 10, 4294967297LL}, |
261 | {"9223372036854775807" , 10, 9223372036854775807LL}, |
262 | |
263 | {"-0" , 10, 0LL}, |
264 | {"-1" , 10, -1LL}, |
265 | {"-2" , 10, -2LL}, |
266 | {"-9223372036854775808" , 10, LLONG_MIN}, |
267 | }; |
268 | TEST_OK(kstrtoll, long long, "%lld" , test_ll_ok); |
269 | } |
270 | |
271 | static void __init test_kstrtoll_fail(void) |
272 | { |
273 | static DEFINE_TEST_FAIL(test_ll_fail) = { |
274 | {"9223372036854775808" , 10}, |
275 | {"9223372036854775809" , 10}, |
276 | {"18446744073709551614" , 10}, |
277 | {"18446744073709551615" , 10}, |
278 | {"-9223372036854775809" , 10}, |
279 | {"-18446744073709551614" , 10}, |
280 | {"-18446744073709551615" , 10}, |
281 | /* sign is first character if any */ |
282 | {"-+1" , 0}, |
283 | {"-+1" , 8}, |
284 | {"-+1" , 10}, |
285 | {"-+1" , 16}, |
286 | }; |
287 | TEST_FAIL(kstrtoll, long long, "%lld" , test_ll_fail); |
288 | } |
289 | |
290 | static void __init test_kstrtou64_ok(void) |
291 | { |
292 | DECLARE_TEST_OK(u64, struct test_u64); |
293 | static DEFINE_TEST_OK(struct test_u64, test_u64_ok) = { |
294 | {"0" , 10, 0}, |
295 | {"1" , 10, 1}, |
296 | {"126" , 10, 126}, |
297 | {"127" , 10, 127}, |
298 | {"128" , 10, 128}, |
299 | {"129" , 10, 129}, |
300 | {"254" , 10, 254}, |
301 | {"255" , 10, 255}, |
302 | {"256" , 10, 256}, |
303 | {"257" , 10, 257}, |
304 | {"32766" , 10, 32766}, |
305 | {"32767" , 10, 32767}, |
306 | {"32768" , 10, 32768}, |
307 | {"32769" , 10, 32769}, |
308 | {"65534" , 10, 65534}, |
309 | {"65535" , 10, 65535}, |
310 | {"65536" , 10, 65536}, |
311 | {"65537" , 10, 65537}, |
312 | {"2147483646" , 10, 2147483646}, |
313 | {"2147483647" , 10, 2147483647}, |
314 | {"2147483648" , 10, 2147483648ULL}, |
315 | {"2147483649" , 10, 2147483649ULL}, |
316 | {"4294967294" , 10, 4294967294ULL}, |
317 | {"4294967295" , 10, 4294967295ULL}, |
318 | {"4294967296" , 10, 4294967296ULL}, |
319 | {"4294967297" , 10, 4294967297ULL}, |
320 | {"9223372036854775806" , 10, 9223372036854775806ULL}, |
321 | {"9223372036854775807" , 10, 9223372036854775807ULL}, |
322 | {"9223372036854775808" , 10, 9223372036854775808ULL}, |
323 | {"9223372036854775809" , 10, 9223372036854775809ULL}, |
324 | {"18446744073709551614" , 10, 18446744073709551614ULL}, |
325 | {"18446744073709551615" , 10, 18446744073709551615ULL}, |
326 | }; |
327 | TEST_OK(kstrtou64, u64, "%llu" , test_u64_ok); |
328 | } |
329 | |
330 | static void __init test_kstrtou64_fail(void) |
331 | { |
332 | static DEFINE_TEST_FAIL(test_u64_fail) = { |
333 | {"-2" , 10}, |
334 | {"-1" , 10}, |
335 | {"18446744073709551616" , 10}, |
336 | {"18446744073709551617" , 10}, |
337 | }; |
338 | TEST_FAIL(kstrtou64, u64, "%llu" , test_u64_fail); |
339 | } |
340 | |
341 | static void __init test_kstrtos64_ok(void) |
342 | { |
343 | DECLARE_TEST_OK(s64, struct test_s64); |
344 | static DEFINE_TEST_OK(struct test_s64, test_s64_ok) = { |
345 | {"-128" , 10, -128}, |
346 | {"-127" , 10, -127}, |
347 | {"-1" , 10, -1}, |
348 | {"0" , 10, 0}, |
349 | {"1" , 10, 1}, |
350 | {"126" , 10, 126}, |
351 | {"127" , 10, 127}, |
352 | {"128" , 10, 128}, |
353 | {"129" , 10, 129}, |
354 | {"254" , 10, 254}, |
355 | {"255" , 10, 255}, |
356 | {"256" , 10, 256}, |
357 | {"257" , 10, 257}, |
358 | {"32766" , 10, 32766}, |
359 | {"32767" , 10, 32767}, |
360 | {"32768" , 10, 32768}, |
361 | {"32769" , 10, 32769}, |
362 | {"65534" , 10, 65534}, |
363 | {"65535" , 10, 65535}, |
364 | {"65536" , 10, 65536}, |
365 | {"65537" , 10, 65537}, |
366 | {"2147483646" , 10, 2147483646}, |
367 | {"2147483647" , 10, 2147483647}, |
368 | {"2147483648" , 10, 2147483648LL}, |
369 | {"2147483649" , 10, 2147483649LL}, |
370 | {"4294967294" , 10, 4294967294LL}, |
371 | {"4294967295" , 10, 4294967295LL}, |
372 | {"4294967296" , 10, 4294967296LL}, |
373 | {"4294967297" , 10, 4294967297LL}, |
374 | {"9223372036854775806" , 10, 9223372036854775806LL}, |
375 | {"9223372036854775807" , 10, 9223372036854775807LL}, |
376 | }; |
377 | TEST_OK(kstrtos64, s64, "%lld" , test_s64_ok); |
378 | } |
379 | |
380 | static void __init test_kstrtos64_fail(void) |
381 | { |
382 | static DEFINE_TEST_FAIL(test_s64_fail) = { |
383 | {"9223372036854775808" , 10}, |
384 | {"9223372036854775809" , 10}, |
385 | {"18446744073709551614" , 10}, |
386 | {"18446744073709551615" , 10}, |
387 | {"18446744073709551616" , 10}, |
388 | {"18446744073709551617" , 10}, |
389 | }; |
390 | TEST_FAIL(kstrtos64, s64, "%lld" , test_s64_fail); |
391 | } |
392 | |
393 | static void __init test_kstrtou32_ok(void) |
394 | { |
395 | DECLARE_TEST_OK(u32, struct test_u32); |
396 | static DEFINE_TEST_OK(struct test_u32, test_u32_ok) = { |
397 | {"0" , 10, 0}, |
398 | {"1" , 10, 1}, |
399 | {"126" , 10, 126}, |
400 | {"127" , 10, 127}, |
401 | {"128" , 10, 128}, |
402 | {"129" , 10, 129}, |
403 | {"254" , 10, 254}, |
404 | {"255" , 10, 255}, |
405 | {"256" , 10, 256}, |
406 | {"257" , 10, 257}, |
407 | {"32766" , 10, 32766}, |
408 | {"32767" , 10, 32767}, |
409 | {"32768" , 10, 32768}, |
410 | {"32769" , 10, 32769}, |
411 | {"65534" , 10, 65534}, |
412 | {"65535" , 10, 65535}, |
413 | {"65536" , 10, 65536}, |
414 | {"65537" , 10, 65537}, |
415 | {"2147483646" , 10, 2147483646}, |
416 | {"2147483647" , 10, 2147483647}, |
417 | {"2147483648" , 10, 2147483648U}, |
418 | {"2147483649" , 10, 2147483649U}, |
419 | {"4294967294" , 10, 4294967294U}, |
420 | {"4294967295" , 10, 4294967295U}, |
421 | }; |
422 | TEST_OK(kstrtou32, u32, "%u" , test_u32_ok); |
423 | } |
424 | |
425 | static void __init test_kstrtou32_fail(void) |
426 | { |
427 | static DEFINE_TEST_FAIL(test_u32_fail) = { |
428 | {"-2" , 10}, |
429 | {"-1" , 10}, |
430 | {"4294967296" , 10}, |
431 | {"4294967297" , 10}, |
432 | {"9223372036854775806" , 10}, |
433 | {"9223372036854775807" , 10}, |
434 | {"9223372036854775808" , 10}, |
435 | {"9223372036854775809" , 10}, |
436 | {"18446744073709551614" , 10}, |
437 | {"18446744073709551615" , 10}, |
438 | {"18446744073709551616" , 10}, |
439 | {"18446744073709551617" , 10}, |
440 | }; |
441 | TEST_FAIL(kstrtou32, u32, "%u" , test_u32_fail); |
442 | } |
443 | |
444 | static void __init test_kstrtos32_ok(void) |
445 | { |
446 | DECLARE_TEST_OK(s32, struct test_s32); |
447 | static DEFINE_TEST_OK(struct test_s32, test_s32_ok) = { |
448 | {"-128" , 10, -128}, |
449 | {"-127" , 10, -127}, |
450 | {"-1" , 10, -1}, |
451 | {"0" , 10, 0}, |
452 | {"1" , 10, 1}, |
453 | {"126" , 10, 126}, |
454 | {"127" , 10, 127}, |
455 | {"128" , 10, 128}, |
456 | {"129" , 10, 129}, |
457 | {"254" , 10, 254}, |
458 | {"255" , 10, 255}, |
459 | {"256" , 10, 256}, |
460 | {"257" , 10, 257}, |
461 | {"32766" , 10, 32766}, |
462 | {"32767" , 10, 32767}, |
463 | {"32768" , 10, 32768}, |
464 | {"32769" , 10, 32769}, |
465 | {"65534" , 10, 65534}, |
466 | {"65535" , 10, 65535}, |
467 | {"65536" , 10, 65536}, |
468 | {"65537" , 10, 65537}, |
469 | {"2147483646" , 10, 2147483646}, |
470 | {"2147483647" , 10, 2147483647}, |
471 | }; |
472 | TEST_OK(kstrtos32, s32, "%d" , test_s32_ok); |
473 | } |
474 | |
475 | static void __init test_kstrtos32_fail(void) |
476 | { |
477 | static DEFINE_TEST_FAIL(test_s32_fail) = { |
478 | {"2147483648" , 10}, |
479 | {"2147483649" , 10}, |
480 | {"4294967294" , 10}, |
481 | {"4294967295" , 10}, |
482 | {"4294967296" , 10}, |
483 | {"4294967297" , 10}, |
484 | {"9223372036854775806" , 10}, |
485 | {"9223372036854775807" , 10}, |
486 | {"9223372036854775808" , 10}, |
487 | {"9223372036854775809" , 10}, |
488 | {"18446744073709551614" , 10}, |
489 | {"18446744073709551615" , 10}, |
490 | {"18446744073709551616" , 10}, |
491 | {"18446744073709551617" , 10}, |
492 | }; |
493 | TEST_FAIL(kstrtos32, s32, "%d" , test_s32_fail); |
494 | } |
495 | |
496 | static void __init test_kstrtou16_ok(void) |
497 | { |
498 | DECLARE_TEST_OK(u16, struct test_u16); |
499 | static DEFINE_TEST_OK(struct test_u16, test_u16_ok) = { |
500 | {"0" , 10, 0}, |
501 | {"1" , 10, 1}, |
502 | {"126" , 10, 126}, |
503 | {"127" , 10, 127}, |
504 | {"128" , 10, 128}, |
505 | {"129" , 10, 129}, |
506 | {"254" , 10, 254}, |
507 | {"255" , 10, 255}, |
508 | {"256" , 10, 256}, |
509 | {"257" , 10, 257}, |
510 | {"32766" , 10, 32766}, |
511 | {"32767" , 10, 32767}, |
512 | {"32768" , 10, 32768}, |
513 | {"32769" , 10, 32769}, |
514 | {"65534" , 10, 65534}, |
515 | {"65535" , 10, 65535}, |
516 | }; |
517 | TEST_OK(kstrtou16, u16, "%hu" , test_u16_ok); |
518 | } |
519 | |
520 | static void __init test_kstrtou16_fail(void) |
521 | { |
522 | static DEFINE_TEST_FAIL(test_u16_fail) = { |
523 | {"-2" , 10}, |
524 | {"-1" , 10}, |
525 | {"65536" , 10}, |
526 | {"65537" , 10}, |
527 | {"2147483646" , 10}, |
528 | {"2147483647" , 10}, |
529 | {"2147483648" , 10}, |
530 | {"2147483649" , 10}, |
531 | {"4294967294" , 10}, |
532 | {"4294967295" , 10}, |
533 | {"4294967296" , 10}, |
534 | {"4294967297" , 10}, |
535 | {"9223372036854775806" , 10}, |
536 | {"9223372036854775807" , 10}, |
537 | {"9223372036854775808" , 10}, |
538 | {"9223372036854775809" , 10}, |
539 | {"18446744073709551614" , 10}, |
540 | {"18446744073709551615" , 10}, |
541 | {"18446744073709551616" , 10}, |
542 | {"18446744073709551617" , 10}, |
543 | }; |
544 | TEST_FAIL(kstrtou16, u16, "%hu" , test_u16_fail); |
545 | } |
546 | |
547 | static void __init test_kstrtos16_ok(void) |
548 | { |
549 | DECLARE_TEST_OK(s16, struct test_s16); |
550 | static DEFINE_TEST_OK(struct test_s16, test_s16_ok) = { |
551 | {"-130" , 10, -130}, |
552 | {"-129" , 10, -129}, |
553 | {"-128" , 10, -128}, |
554 | {"-127" , 10, -127}, |
555 | {"-1" , 10, -1}, |
556 | {"0" , 10, 0}, |
557 | {"1" , 10, 1}, |
558 | {"126" , 10, 126}, |
559 | {"127" , 10, 127}, |
560 | {"128" , 10, 128}, |
561 | {"129" , 10, 129}, |
562 | {"254" , 10, 254}, |
563 | {"255" , 10, 255}, |
564 | {"256" , 10, 256}, |
565 | {"257" , 10, 257}, |
566 | {"32766" , 10, 32766}, |
567 | {"32767" , 10, 32767}, |
568 | }; |
569 | TEST_OK(kstrtos16, s16, "%hd" , test_s16_ok); |
570 | } |
571 | |
572 | static void __init test_kstrtos16_fail(void) |
573 | { |
574 | static DEFINE_TEST_FAIL(test_s16_fail) = { |
575 | {"32768" , 10}, |
576 | {"32769" , 10}, |
577 | {"65534" , 10}, |
578 | {"65535" , 10}, |
579 | {"65536" , 10}, |
580 | {"65537" , 10}, |
581 | {"2147483646" , 10}, |
582 | {"2147483647" , 10}, |
583 | {"2147483648" , 10}, |
584 | {"2147483649" , 10}, |
585 | {"4294967294" , 10}, |
586 | {"4294967295" , 10}, |
587 | {"4294967296" , 10}, |
588 | {"4294967297" , 10}, |
589 | {"9223372036854775806" , 10}, |
590 | {"9223372036854775807" , 10}, |
591 | {"9223372036854775808" , 10}, |
592 | {"9223372036854775809" , 10}, |
593 | {"18446744073709551614" , 10}, |
594 | {"18446744073709551615" , 10}, |
595 | {"18446744073709551616" , 10}, |
596 | {"18446744073709551617" , 10}, |
597 | }; |
598 | TEST_FAIL(kstrtos16, s16, "%hd" , test_s16_fail); |
599 | } |
600 | |
601 | static void __init test_kstrtou8_ok(void) |
602 | { |
603 | DECLARE_TEST_OK(u8, struct test_u8); |
604 | static DEFINE_TEST_OK(struct test_u8, test_u8_ok) = { |
605 | {"0" , 10, 0}, |
606 | {"1" , 10, 1}, |
607 | {"126" , 10, 126}, |
608 | {"127" , 10, 127}, |
609 | {"128" , 10, 128}, |
610 | {"129" , 10, 129}, |
611 | {"254" , 10, 254}, |
612 | {"255" , 10, 255}, |
613 | }; |
614 | TEST_OK(kstrtou8, u8, "%hhu" , test_u8_ok); |
615 | } |
616 | |
617 | static void __init test_kstrtou8_fail(void) |
618 | { |
619 | static DEFINE_TEST_FAIL(test_u8_fail) = { |
620 | {"-2" , 10}, |
621 | {"-1" , 10}, |
622 | {"256" , 10}, |
623 | {"257" , 10}, |
624 | {"32766" , 10}, |
625 | {"32767" , 10}, |
626 | {"32768" , 10}, |
627 | {"32769" , 10}, |
628 | {"65534" , 10}, |
629 | {"65535" , 10}, |
630 | {"65536" , 10}, |
631 | {"65537" , 10}, |
632 | {"2147483646" , 10}, |
633 | {"2147483647" , 10}, |
634 | {"2147483648" , 10}, |
635 | {"2147483649" , 10}, |
636 | {"4294967294" , 10}, |
637 | {"4294967295" , 10}, |
638 | {"4294967296" , 10}, |
639 | {"4294967297" , 10}, |
640 | {"9223372036854775806" , 10}, |
641 | {"9223372036854775807" , 10}, |
642 | {"9223372036854775808" , 10}, |
643 | {"9223372036854775809" , 10}, |
644 | {"18446744073709551614" , 10}, |
645 | {"18446744073709551615" , 10}, |
646 | {"18446744073709551616" , 10}, |
647 | {"18446744073709551617" , 10}, |
648 | }; |
649 | TEST_FAIL(kstrtou8, u8, "%hhu" , test_u8_fail); |
650 | } |
651 | |
652 | static void __init test_kstrtos8_ok(void) |
653 | { |
654 | DECLARE_TEST_OK(s8, struct test_s8); |
655 | static DEFINE_TEST_OK(struct test_s8, test_s8_ok) = { |
656 | {"-128" , 10, -128}, |
657 | {"-127" , 10, -127}, |
658 | {"-1" , 10, -1}, |
659 | {"0" , 10, 0}, |
660 | {"1" , 10, 1}, |
661 | {"126" , 10, 126}, |
662 | {"127" , 10, 127}, |
663 | }; |
664 | TEST_OK(kstrtos8, s8, "%hhd" , test_s8_ok); |
665 | } |
666 | |
667 | static void __init test_kstrtos8_fail(void) |
668 | { |
669 | static DEFINE_TEST_FAIL(test_s8_fail) = { |
670 | {"-130" , 10}, |
671 | {"-129" , 10}, |
672 | {"128" , 10}, |
673 | {"129" , 10}, |
674 | {"254" , 10}, |
675 | {"255" , 10}, |
676 | {"256" , 10}, |
677 | {"257" , 10}, |
678 | {"32766" , 10}, |
679 | {"32767" , 10}, |
680 | {"32768" , 10}, |
681 | {"32769" , 10}, |
682 | {"65534" , 10}, |
683 | {"65535" , 10}, |
684 | {"65536" , 10}, |
685 | {"65537" , 10}, |
686 | {"2147483646" , 10}, |
687 | {"2147483647" , 10}, |
688 | {"2147483648" , 10}, |
689 | {"2147483649" , 10}, |
690 | {"4294967294" , 10}, |
691 | {"4294967295" , 10}, |
692 | {"4294967296" , 10}, |
693 | {"4294967297" , 10}, |
694 | {"9223372036854775806" , 10}, |
695 | {"9223372036854775807" , 10}, |
696 | {"9223372036854775808" , 10}, |
697 | {"9223372036854775809" , 10}, |
698 | {"18446744073709551614" , 10}, |
699 | {"18446744073709551615" , 10}, |
700 | {"18446744073709551616" , 10}, |
701 | {"18446744073709551617" , 10}, |
702 | }; |
703 | TEST_FAIL(kstrtos8, s8, "%hhd" , test_s8_fail); |
704 | } |
705 | |
706 | static int __init test_kstrtox_init(void) |
707 | { |
708 | test_kstrtoull_ok(); |
709 | test_kstrtoull_fail(); |
710 | test_kstrtoll_ok(); |
711 | test_kstrtoll_fail(); |
712 | |
713 | test_kstrtou64_ok(); |
714 | test_kstrtou64_fail(); |
715 | test_kstrtos64_ok(); |
716 | test_kstrtos64_fail(); |
717 | |
718 | test_kstrtou32_ok(); |
719 | test_kstrtou32_fail(); |
720 | test_kstrtos32_ok(); |
721 | test_kstrtos32_fail(); |
722 | |
723 | test_kstrtou16_ok(); |
724 | test_kstrtou16_fail(); |
725 | test_kstrtos16_ok(); |
726 | test_kstrtos16_fail(); |
727 | |
728 | test_kstrtou8_ok(); |
729 | test_kstrtou8_fail(); |
730 | test_kstrtos8_ok(); |
731 | test_kstrtos8_fail(); |
732 | return -EINVAL; |
733 | } |
734 | module_init(test_kstrtox_init); |
735 | MODULE_LICENSE("Dual BSD/GPL" ); |
736 | |