lib/test-string_helpers.c

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