test-string_helpers.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484
  1. /*
  2. * Test cases for lib/string_helpers.c module.
  3. */
  4. #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  5. #include <linux/init.h>
  6. #include <linux/kernel.h>
  7. #include <linux/slab.h>
  8. #include <linux/module.h>
  9. #include <linux/random.h>
  10. #include <linux/string.h>
  11. #include <linux/string_helpers.h>
  12. static __init bool test_string_check_buf(const char *name, unsigned int flags,
  13. char *in, size_t p,
  14. char *out_real, size_t q_real,
  15. char *out_test, size_t q_test)
  16. {
  17. if (q_real == q_test && !memcmp(out_test, out_real, q_test))
  18. return true;
  19. pr_warn("Test '%s' failed: flags = %u\n", name, flags);
  20. print_hex_dump(KERN_WARNING, "Input: ", DUMP_PREFIX_NONE, 16, 1,
  21. in, p, true);
  22. print_hex_dump(KERN_WARNING, "Expected: ", DUMP_PREFIX_NONE, 16, 1,
  23. out_test, q_test, true);
  24. print_hex_dump(KERN_WARNING, "Got: ", DUMP_PREFIX_NONE, 16, 1,
  25. out_real, q_real, true);
  26. return false;
  27. }
  28. struct test_string {
  29. const char *in;
  30. const char *out;
  31. unsigned int flags;
  32. };
  33. static const struct test_string strings[] __initconst = {
  34. {
  35. .in = "\\f\\ \\n\\r\\t\\v",
  36. .out = "\f\\ \n\r\t\v",
  37. .flags = UNESCAPE_SPACE,
  38. },
  39. {
  40. .in = "\\40\\1\\387\\0064\\05\\040\\8a\\110\\777",
  41. .out = " \001\00387\0064\005 \\8aH?7",
  42. .flags = UNESCAPE_OCTAL,
  43. },
  44. {
  45. .in = "\\xv\\xa\\x2c\\xD\\x6f2",
  46. .out = "\\xv\n,\ro2",
  47. .flags = UNESCAPE_HEX,
  48. },
  49. {
  50. .in = "\\h\\\\\\\"\\a\\e\\",
  51. .out = "\\h\\\"\a\e\\",
  52. .flags = UNESCAPE_SPECIAL,
  53. },
  54. };
  55. static void __init test_string_unescape(const char *name, unsigned int flags,
  56. bool inplace)
  57. {
  58. int q_real = 256;
  59. char *in = kmalloc(q_real, GFP_KERNEL);
  60. char *out_test = kmalloc(q_real, GFP_KERNEL);
  61. char *out_real = kmalloc(q_real, GFP_KERNEL);
  62. int i, p = 0, q_test = 0;
  63. if (!in || !out_test || !out_real)
  64. goto out;
  65. for (i = 0; i < ARRAY_SIZE(strings); i++) {
  66. const char *s = strings[i].in;
  67. int len = strlen(strings[i].in);
  68. /* Copy string to in buffer */
  69. memcpy(&in[p], s, len);
  70. p += len;
  71. /* Copy expected result for given flags */
  72. if (flags & strings[i].flags) {
  73. s = strings[i].out;
  74. len = strlen(strings[i].out);
  75. }
  76. memcpy(&out_test[q_test], s, len);
  77. q_test += len;
  78. }
  79. in[p++] = '\0';
  80. /* Call string_unescape and compare result */
  81. if (inplace) {
  82. memcpy(out_real, in, p);
  83. if (flags == UNESCAPE_ANY)
  84. q_real = string_unescape_any_inplace(out_real);
  85. else
  86. q_real = string_unescape_inplace(out_real, flags);
  87. } else if (flags == UNESCAPE_ANY) {
  88. q_real = string_unescape_any(in, out_real, q_real);
  89. } else {
  90. q_real = string_unescape(in, out_real, q_real, flags);
  91. }
  92. test_string_check_buf(name, flags, in, p - 1, out_real, q_real,
  93. out_test, q_test);
  94. out:
  95. kfree(out_real);
  96. kfree(out_test);
  97. kfree(in);
  98. }
  99. struct test_string_1 {
  100. const char *out;
  101. unsigned int flags;
  102. };
  103. #define TEST_STRING_2_MAX_S1 32
  104. struct test_string_2 {
  105. const char *in;
  106. struct test_string_1 s1[TEST_STRING_2_MAX_S1];
  107. };
  108. #define TEST_STRING_2_DICT_0 NULL
  109. static const struct test_string_2 escape0[] __initconst = {{
  110. .in = "\f\\ \n\r\t\v",
  111. .s1 = {{
  112. .out = "\\f\\ \\n\\r\\t\\v",
  113. .flags = ESCAPE_SPACE,
  114. },{
  115. .out = "\\f\\134\\040\\n\\r\\t\\v",
  116. .flags = ESCAPE_SPACE | ESCAPE_OCTAL,
  117. },{
  118. .out = "\\f\\x5c\\x20\\n\\r\\t\\v",
  119. .flags = ESCAPE_SPACE | ESCAPE_HEX,
  120. },{
  121. /* terminator */
  122. }},
  123. },{
  124. .in = "\\h\\\"\a\e\\",
  125. .s1 = {{
  126. .out = "\\\\h\\\\\"\\a\\e\\\\",
  127. .flags = ESCAPE_SPECIAL,
  128. },{
  129. .out = "\\\\\\150\\\\\\042\\a\\e\\\\",
  130. .flags = ESCAPE_SPECIAL | ESCAPE_OCTAL,
  131. },{
  132. .out = "\\\\\\x68\\\\\\x22\\a\\e\\\\",
  133. .flags = ESCAPE_SPECIAL | ESCAPE_HEX,
  134. },{
  135. /* terminator */
  136. }},
  137. },{
  138. .in = "\eb \\C\007\"\x90\r]",
  139. .s1 = {{
  140. .out = "\eb \\C\007\"\x90\\r]",
  141. .flags = ESCAPE_SPACE,
  142. },{
  143. .out = "\\eb \\\\C\\a\"\x90\r]",
  144. .flags = ESCAPE_SPECIAL,
  145. },{
  146. .out = "\\eb \\\\C\\a\"\x90\\r]",
  147. .flags = ESCAPE_SPACE | ESCAPE_SPECIAL,
  148. },{
  149. .out = "\\033\\142\\040\\134\\103\\007\\042\\220\\015\\135",
  150. .flags = ESCAPE_OCTAL,
  151. },{
  152. .out = "\\033\\142\\040\\134\\103\\007\\042\\220\\r\\135",
  153. .flags = ESCAPE_SPACE | ESCAPE_OCTAL,
  154. },{
  155. .out = "\\e\\142\\040\\\\\\103\\a\\042\\220\\015\\135",
  156. .flags = ESCAPE_SPECIAL | ESCAPE_OCTAL,
  157. },{
  158. .out = "\\e\\142\\040\\\\\\103\\a\\042\\220\\r\\135",
  159. .flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_OCTAL,
  160. },{
  161. .out = "\eb \\C\007\"\x90\r]",
  162. .flags = ESCAPE_NP,
  163. },{
  164. .out = "\eb \\C\007\"\x90\\r]",
  165. .flags = ESCAPE_SPACE | ESCAPE_NP,
  166. },{
  167. .out = "\\eb \\C\\a\"\x90\r]",
  168. .flags = ESCAPE_SPECIAL | ESCAPE_NP,
  169. },{
  170. .out = "\\eb \\C\\a\"\x90\\r]",
  171. .flags = ESCAPE_SPACE | ESCAPE_SPECIAL | ESCAPE_NP,
  172. },{
  173. .out = "\\033b \\C\\007\"\\220\\015]",
  174. .flags = ESCAPE_OCTAL | ESCAPE_NP,
  175. },{
  176. .out = "\\033b \\C\\007\"\\220\\r]",
  177. .flags = ESCAPE_SPACE | ESCAPE_OCTAL | ESCAPE_NP,
  178. },{
  179. .out = "\\eb \\C\\a\"\\220\\r]",
  180. .flags = ESCAPE_SPECIAL | ESCAPE_SPACE | ESCAPE_OCTAL |
  181. ESCAPE_NP,
  182. },{
  183. .out = "\\x1bb \\C\\x07\"\\x90\\x0d]",
  184. .flags = ESCAPE_NP | ESCAPE_HEX,
  185. },{
  186. /* terminator */
  187. }},
  188. },{
  189. /* terminator */
  190. }};
  191. #define TEST_STRING_2_DICT_1 "b\\ \t\r"
  192. static const struct test_string_2 escape1[] __initconst = {{
  193. .in = "\f\\ \n\r\t\v",
  194. .s1 = {{
  195. .out = "\f\\134\\040\n\\015\\011\v",
  196. .flags = ESCAPE_OCTAL,
  197. },{
  198. .out = "\f\\x5c\\x20\n\\x0d\\x09\v",
  199. .flags = ESCAPE_HEX,
  200. },{
  201. /* terminator */
  202. }},
  203. },{
  204. .in = "\\h\\\"\a\e\\",
  205. .s1 = {{
  206. .out = "\\134h\\134\"\a\e\\134",
  207. .flags = ESCAPE_OCTAL,
  208. },{
  209. /* terminator */
  210. }},
  211. },{
  212. .in = "\eb \\C\007\"\x90\r]",
  213. .s1 = {{
  214. .out = "\e\\142\\040\\134C\007\"\x90\\015]",
  215. .flags = ESCAPE_OCTAL,
  216. },{
  217. /* terminator */
  218. }},
  219. },{
  220. /* terminator */
  221. }};
  222. static const struct test_string strings_upper[] __initconst = {
  223. {
  224. .in = "abcdefgh1234567890test",
  225. .out = "ABCDEFGH1234567890TEST",
  226. },
  227. {
  228. .in = "abCdeFgH1234567890TesT",
  229. .out = "ABCDEFGH1234567890TEST",
  230. },
  231. };
  232. static const struct test_string strings_lower[] __initconst = {
  233. {
  234. .in = "ABCDEFGH1234567890TEST",
  235. .out = "abcdefgh1234567890test",
  236. },
  237. {
  238. .in = "abCdeFgH1234567890TesT",
  239. .out = "abcdefgh1234567890test",
  240. },
  241. };
  242. static __init const char *test_string_find_match(const struct test_string_2 *s2,
  243. unsigned int flags)
  244. {
  245. const struct test_string_1 *s1 = s2->s1;
  246. unsigned int i;
  247. if (!flags)
  248. return s2->in;
  249. /* Test cases are NULL-aware */
  250. flags &= ~ESCAPE_NULL;
  251. /* ESCAPE_OCTAL has a higher priority */
  252. if (flags & ESCAPE_OCTAL)
  253. flags &= ~ESCAPE_HEX;
  254. for (i = 0; i < TEST_STRING_2_MAX_S1 && s1->out; i++, s1++)
  255. if (s1->flags == flags)
  256. return s1->out;
  257. return NULL;
  258. }
  259. static __init void
  260. test_string_escape_overflow(const char *in, int p, unsigned int flags, const char *esc,
  261. int q_test, const char *name)
  262. {
  263. int q_real;
  264. q_real = string_escape_mem(in, p, NULL, 0, flags, esc);
  265. if (q_real != q_test)
  266. pr_warn("Test '%s' failed: flags = %u, osz = 0, expected %d, got %d\n",
  267. name, flags, q_test, q_real);
  268. }
  269. static __init void test_string_escape(const char *name,
  270. const struct test_string_2 *s2,
  271. unsigned int flags, const char *esc)
  272. {
  273. size_t out_size = 512;
  274. char *out_test = kmalloc(out_size, GFP_KERNEL);
  275. char *out_real = kmalloc(out_size, GFP_KERNEL);
  276. char *in = kmalloc(256, GFP_KERNEL);
  277. int p = 0, q_test = 0;
  278. int q_real;
  279. if (!out_test || !out_real || !in)
  280. goto out;
  281. for (; s2->in; s2++) {
  282. const char *out;
  283. int len;
  284. /* NULL injection */
  285. if (flags & ESCAPE_NULL) {
  286. in[p++] = '\0';
  287. out_test[q_test++] = '\\';
  288. out_test[q_test++] = '0';
  289. }
  290. /* Don't try strings that have no output */
  291. out = test_string_find_match(s2, flags);
  292. if (!out)
  293. continue;
  294. /* Copy string to in buffer */
  295. len = strlen(s2->in);
  296. memcpy(&in[p], s2->in, len);
  297. p += len;
  298. /* Copy expected result for given flags */
  299. len = strlen(out);
  300. memcpy(&out_test[q_test], out, len);
  301. q_test += len;
  302. }
  303. q_real = string_escape_mem(in, p, out_real, out_size, flags, esc);
  304. test_string_check_buf(name, flags, in, p, out_real, q_real, out_test,
  305. q_test);
  306. test_string_escape_overflow(in, p, flags, esc, q_test, name);
  307. out:
  308. kfree(in);
  309. kfree(out_real);
  310. kfree(out_test);
  311. }
  312. #define string_get_size_maxbuf 16
  313. #define test_string_get_size_one(size, blk_size, exp_result10, exp_result2) \
  314. do { \
  315. BUILD_BUG_ON(sizeof(exp_result10) >= string_get_size_maxbuf); \
  316. BUILD_BUG_ON(sizeof(exp_result2) >= string_get_size_maxbuf); \
  317. __test_string_get_size((size), (blk_size), (exp_result10), \
  318. (exp_result2)); \
  319. } while (0)
  320. static __init void test_string_get_size_check(const char *units,
  321. const char *exp,
  322. char *res,
  323. const u64 size,
  324. const u64 blk_size)
  325. {
  326. if (!memcmp(res, exp, strlen(exp) + 1))
  327. return;
  328. res[string_get_size_maxbuf - 1] = '\0';
  329. pr_warn("Test 'test_string_get_size' failed!\n");
  330. pr_warn("string_get_size(size = %llu, blk_size = %llu, units = %s)\n",
  331. size, blk_size, units);
  332. pr_warn("expected: '%s', got '%s'\n", exp, res);
  333. }
  334. static __init void __test_string_get_size(const u64 size, const u64 blk_size,
  335. const char *exp_result10,
  336. const char *exp_result2)
  337. {
  338. char buf10[string_get_size_maxbuf];
  339. char buf2[string_get_size_maxbuf];
  340. string_get_size(size, blk_size, STRING_UNITS_10, buf10, sizeof(buf10));
  341. string_get_size(size, blk_size, STRING_UNITS_2, buf2, sizeof(buf2));
  342. test_string_get_size_check("STRING_UNITS_10", exp_result10, buf10,
  343. size, blk_size);
  344. test_string_get_size_check("STRING_UNITS_2", exp_result2, buf2,
  345. size, blk_size);
  346. }
  347. static __init void test_string_get_size(void)
  348. {
  349. /* small values */
  350. test_string_get_size_one(0, 512, "0 B", "0 B");
  351. test_string_get_size_one(1, 512, "512 B", "512 B");
  352. test_string_get_size_one(1100, 1, "1.10 kB", "1.07 KiB");
  353. /* normal values */
  354. test_string_get_size_one(16384, 512, "8.39 MB", "8.00 MiB");
  355. test_string_get_size_one(500118192, 512, "256 GB", "238 GiB");
  356. test_string_get_size_one(8192, 4096, "33.6 MB", "32.0 MiB");
  357. /* weird block sizes */
  358. test_string_get_size_one(3000, 1900, "5.70 MB", "5.44 MiB");
  359. /* huge values */
  360. test_string_get_size_one(U64_MAX, 4096, "75.6 ZB", "64.0 ZiB");
  361. test_string_get_size_one(4096, U64_MAX, "75.6 ZB", "64.0 ZiB");
  362. }
  363. static void __init test_string_upper_lower(void)
  364. {
  365. char *dst;
  366. int i;
  367. for (i = 0; i < ARRAY_SIZE(strings_upper); i++) {
  368. const char *s = strings_upper[i].in;
  369. int len = strlen(strings_upper[i].in) + 1;
  370. dst = kmalloc(len, GFP_KERNEL);
  371. if (!dst)
  372. return;
  373. string_upper(dst, s);
  374. if (memcmp(dst, strings_upper[i].out, len)) {
  375. pr_warn("Test 'string_upper' failed : expected %s, got %s!\n",
  376. strings_upper[i].out, dst);
  377. kfree(dst);
  378. return;
  379. }
  380. kfree(dst);
  381. }
  382. for (i = 0; i < ARRAY_SIZE(strings_lower); i++) {
  383. const char *s = strings_lower[i].in;
  384. int len = strlen(strings_lower[i].in) + 1;
  385. dst = kmalloc(len, GFP_KERNEL);
  386. if (!dst)
  387. return;
  388. string_lower(dst, s);
  389. if (memcmp(dst, strings_lower[i].out, len)) {
  390. pr_warn("Test 'string_lower failed : : expected %s, got %s!\n",
  391. strings_lower[i].out, dst);
  392. kfree(dst);
  393. return;
  394. }
  395. kfree(dst);
  396. }
  397. }
  398. static int __init test_string_helpers_init(void)
  399. {
  400. unsigned int i;
  401. pr_info("Running tests...\n");
  402. for (i = 0; i < UNESCAPE_ANY + 1; i++)
  403. test_string_unescape("unescape", i, false);
  404. test_string_unescape("unescape inplace",
  405. get_random_int() % (UNESCAPE_ANY + 1), true);
  406. /* Without dictionary */
  407. for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++)
  408. test_string_escape("escape 0", escape0, i, TEST_STRING_2_DICT_0);
  409. /* With dictionary */
  410. for (i = 0; i < (ESCAPE_ANY_NP | ESCAPE_HEX) + 1; i++)
  411. test_string_escape("escape 1", escape1, i, TEST_STRING_2_DICT_1);
  412. /* Test string_get_size() */
  413. test_string_get_size();
  414. /* Test string upper(), string_lower() */
  415. test_string_upper_lower();
  416. return -EINVAL;
  417. }
  418. module_init(test_string_helpers_init);
  419. MODULE_LICENSE("Dual BSD/GPL");