1 /* SPDX-License-Identifier: BSD-3-Clause 2 * Copyright (C) 2017 Intel Corporation. 3 * Copyright (c) 2022, NVIDIA CORPORATION & AFFILIATES. 4 * All rights reserved. 5 */ 6 7 #include "spdk/stdinc.h" 8 9 #include "spdk_internal/cunit.h" 10 11 #include "util/string.c" 12 13 static void 14 test_parse_ip_addr(void) 15 { 16 int rc; 17 char *host; 18 char *port; 19 char ip[255]; 20 21 /* IPv4 */ 22 snprintf(ip, 255, "%s", "192.168.0.1"); 23 rc = spdk_parse_ip_addr(ip, &host, &port); 24 CU_ASSERT_EQUAL(rc, 0); 25 SPDK_CU_ASSERT_FATAL(host != NULL); 26 CU_ASSERT(strcmp(host, "192.168.0.1") == 0); 27 CU_ASSERT_EQUAL(strlen(host), 11); 28 CU_ASSERT_EQUAL(port, NULL); 29 30 /* IPv4 with port */ 31 snprintf(ip, 255, "%s", "123.456.789.0:5520"); 32 rc = spdk_parse_ip_addr(ip, &host, &port); 33 CU_ASSERT_EQUAL(rc, 0); 34 SPDK_CU_ASSERT_FATAL(host != NULL); 35 CU_ASSERT(strcmp(host, "123.456.789.0") == 0); 36 CU_ASSERT_EQUAL(strlen(host), 13); 37 SPDK_CU_ASSERT_FATAL(port != NULL); 38 CU_ASSERT(strcmp(port, "5520") == 0); 39 CU_ASSERT_EQUAL(strlen(port), 4); 40 41 /* IPv6 */ 42 snprintf(ip, 255, "%s", "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"); 43 rc = spdk_parse_ip_addr(ip, &host, &port); 44 CU_ASSERT_EQUAL(rc, 0); 45 SPDK_CU_ASSERT_FATAL(host != NULL); 46 CU_ASSERT(strcmp(host, "2001:db8:85a3:8d3:1319:8a2e:370:7348") == 0); 47 CU_ASSERT_EQUAL(strlen(host), 36); 48 CU_ASSERT_EQUAL(port, NULL); 49 50 /* IPv6 with port */ 51 snprintf(ip, 255, "%s", "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"); 52 rc = spdk_parse_ip_addr(ip, &host, &port); 53 CU_ASSERT_EQUAL(rc, 0); 54 SPDK_CU_ASSERT_FATAL(host != NULL); 55 CU_ASSERT(strcmp(host, "2001:db8:85a3:8d3:1319:8a2e:370:7348") == 0); 56 CU_ASSERT_EQUAL(strlen(host), 36); 57 SPDK_CU_ASSERT_FATAL(port != NULL); 58 CU_ASSERT(strcmp(port, "443") == 0); 59 CU_ASSERT_EQUAL(strlen(port), 3); 60 61 /* IPv6 dangling colon */ 62 snprintf(ip, 255, "%s", "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:"); 63 rc = spdk_parse_ip_addr(ip, &host, &port); 64 CU_ASSERT_EQUAL(rc, 0); 65 SPDK_CU_ASSERT_FATAL(host != NULL); 66 CU_ASSERT(strcmp(host, "2001:db8:85a3:8d3:1319:8a2e:370:7348") == 0); 67 CU_ASSERT_EQUAL(strlen(host), 36); 68 CU_ASSERT_EQUAL(port, NULL); 69 } 70 71 static void 72 test_str_chomp(void) 73 { 74 char s[1024]; 75 76 /* One \n newline */ 77 snprintf(s, sizeof(s), "%s", "hello world\n"); 78 CU_ASSERT(spdk_str_chomp(s) == 1); 79 CU_ASSERT(strcmp(s, "hello world") == 0); 80 81 /* One \r\n newline */ 82 snprintf(s, sizeof(s), "%s", "hello world\r\n"); 83 CU_ASSERT(spdk_str_chomp(s) == 2); 84 CU_ASSERT(strcmp(s, "hello world") == 0); 85 86 /* No newlines */ 87 snprintf(s, sizeof(s), "%s", "hello world"); 88 CU_ASSERT(spdk_str_chomp(s) == 0); 89 CU_ASSERT(strcmp(s, "hello world") == 0); 90 91 /* Two newlines */ 92 snprintf(s, sizeof(s), "%s", "hello world\n\n"); 93 CU_ASSERT(spdk_str_chomp(s) == 2); 94 CU_ASSERT(strcmp(s, "hello world") == 0); 95 96 /* Empty string */ 97 snprintf(s, sizeof(s), "%s", ""); 98 CU_ASSERT(spdk_str_chomp(s) == 0); 99 CU_ASSERT(strcmp(s, "") == 0); 100 101 /* One-character string with only \n */ 102 snprintf(s, sizeof(s), "%s", "\n"); 103 CU_ASSERT(spdk_str_chomp(s) == 1); 104 CU_ASSERT(strcmp(s, "") == 0); 105 106 /* One-character string without a newline */ 107 snprintf(s, sizeof(s), "%s", "a"); 108 CU_ASSERT(spdk_str_chomp(s) == 0); 109 CU_ASSERT(strcmp(s, "a") == 0); 110 } 111 112 static void 113 test_parse_capacity(void) 114 { 115 char str[128]; 116 uint64_t cap; 117 int rc; 118 bool has_prefix = true; 119 120 rc = spdk_parse_capacity("472", &cap, &has_prefix); 121 CU_ASSERT(rc == 0); 122 CU_ASSERT(cap == 472); 123 CU_ASSERT(has_prefix == false); 124 125 snprintf(str, sizeof(str), "%"PRIu64, UINT64_MAX); 126 rc = spdk_parse_capacity(str, &cap, &has_prefix); 127 CU_ASSERT(rc == 0); 128 CU_ASSERT(cap == UINT64_MAX); 129 CU_ASSERT(has_prefix == false); 130 131 rc = spdk_parse_capacity("12k", &cap, &has_prefix); 132 CU_ASSERT(rc == 0); 133 CU_ASSERT(cap == 12 * 1024); 134 CU_ASSERT(has_prefix == true); 135 136 rc = spdk_parse_capacity("12K", &cap, &has_prefix); 137 CU_ASSERT(rc == 0); 138 CU_ASSERT(cap == 12 * 1024); 139 CU_ASSERT(has_prefix == true); 140 141 rc = spdk_parse_capacity("12KB", &cap, &has_prefix); 142 CU_ASSERT(rc == 0); 143 CU_ASSERT(cap == 12 * 1024); 144 CU_ASSERT(has_prefix == true); 145 146 rc = spdk_parse_capacity("100M", &cap, &has_prefix); 147 CU_ASSERT(rc == 0); 148 CU_ASSERT(cap == 100 * 1024 * 1024); 149 CU_ASSERT(has_prefix == true); 150 151 rc = spdk_parse_capacity("128M", &cap, &has_prefix); 152 CU_ASSERT(rc == 0); 153 CU_ASSERT(cap == 128 * 1024 * 1024); 154 CU_ASSERT(has_prefix == true); 155 156 rc = spdk_parse_capacity("4G", &cap, &has_prefix); 157 CU_ASSERT(rc == 0); 158 CU_ASSERT(cap == 4ULL * 1024 * 1024 * 1024); 159 CU_ASSERT(has_prefix == true); 160 161 rc = spdk_parse_capacity("100M 512k", &cap, &has_prefix); 162 CU_ASSERT(rc == 0); 163 CU_ASSERT(cap == 100ULL * 1024 * 1024); 164 165 rc = spdk_parse_capacity("12k8K", &cap, &has_prefix); 166 CU_ASSERT(rc == 0); 167 CU_ASSERT(cap == 12 * 1024); 168 CU_ASSERT(has_prefix == true); 169 170 /* Non-number */ 171 rc = spdk_parse_capacity("G", &cap, &has_prefix); 172 CU_ASSERT(rc != 0); 173 174 rc = spdk_parse_capacity("darsto", &cap, &has_prefix); 175 CU_ASSERT(rc != 0); 176 } 177 178 static void 179 test_sprintf_append_realloc(void) 180 { 181 char *str1, *str2, *str3, *str4; 182 183 /* Test basic functionality. */ 184 str1 = spdk_sprintf_alloc("hello world\ngood morning\n" \ 185 "good afternoon\ngood evening\n"); 186 SPDK_CU_ASSERT_FATAL(str1 != NULL); 187 188 str2 = spdk_sprintf_append_realloc(NULL, "hello world\n"); 189 SPDK_CU_ASSERT_FATAL(str2); 190 191 str2 = spdk_sprintf_append_realloc(str2, "good morning\n"); 192 SPDK_CU_ASSERT_FATAL(str2); 193 194 str2 = spdk_sprintf_append_realloc(str2, "good afternoon\n"); 195 SPDK_CU_ASSERT_FATAL(str2); 196 197 str2 = spdk_sprintf_append_realloc(str2, "good evening\n"); 198 SPDK_CU_ASSERT_FATAL(str2); 199 200 CU_ASSERT(strcmp(str1, str2) == 0); 201 202 free(str1); 203 free(str2); 204 205 /* Test doubling buffer size. */ 206 str3 = spdk_sprintf_append_realloc(NULL, "aaaaaaaaaa\n"); 207 str3 = spdk_sprintf_append_realloc(str3, "bbbbbbbbbb\n"); 208 str3 = spdk_sprintf_append_realloc(str3, "cccccccccc\n"); 209 210 str4 = malloc(33 + 1); 211 memset(&str4[0], 'a', 10); 212 str4[10] = '\n'; 213 memset(&str4[11], 'b', 10); 214 str4[21] = '\n'; 215 memset(&str4[22], 'c', 10); 216 str4[32] = '\n'; 217 str4[33] = 0; 218 219 CU_ASSERT(strcmp(str3, str4) == 0); 220 221 free(str3); 222 free(str4); 223 } 224 225 static void 226 generate_string(char *str, size_t len, int64_t limit, int adjust) 227 { 228 /* There isn't a portable way of handling the arithmetic, so */ 229 /* perform the calculation in two parts to avoid overflow */ 230 int64_t hi = (limit / 10) + (adjust / 10); 231 int64_t lo = (limit % 10) + (adjust % 10); 232 233 /* limit is large and adjust is small, so hi part will be */ 234 /* non-zero even if there is a carry, but check it */ 235 CU_ASSERT(hi < -1 || hi > 1); 236 237 /* Correct a difference in sign */ 238 if ((hi < 0) != (lo < 0) && lo != 0) { 239 lo += (hi < 0) ? -10 : 10; 240 hi += (hi < 0) ? 1 : -1; 241 } 242 243 snprintf(str, len, "%" PRId64 "%01" PRId64, hi + (lo / 10), 244 (lo < 0) ? (-lo % 10) : (lo % 10)); 245 } 246 247 static void 248 test_strtol(void) 249 { 250 long int val; 251 char str[256]; 252 253 const char *val1 = "no_digits"; 254 /* digits + chars */ 255 const char *val8 = "10_is_ten"; 256 /* chars + digits */ 257 const char *val9 = "ten_is_10"; 258 /* all zeroes */ 259 const char *val10 = "00000000"; 260 /* leading minus sign, but not negative */ 261 const char *val11 = "-0"; 262 263 val = spdk_strtol(val1, 10); 264 CU_ASSERT(val == -EINVAL); 265 266 /* LONG_MIN - 1 */ 267 generate_string(str, sizeof(str), LONG_MIN, -1); 268 val = spdk_strtol(str, 10); 269 CU_ASSERT(val == -ERANGE); 270 271 /* LONG_MIN */ 272 generate_string(str, sizeof(str), LONG_MIN, 0); 273 val = spdk_strtol(str, 10); 274 CU_ASSERT(val == -ERANGE); 275 276 /* LONG_MIN + 1 */ 277 generate_string(str, sizeof(str), LONG_MIN, +1); 278 val = spdk_strtol(str, 10); 279 CU_ASSERT(val == -ERANGE); 280 281 /* LONG_MAX - 1 */ 282 generate_string(str, sizeof(str), LONG_MAX, -1); 283 val = spdk_strtol(str, 10); 284 CU_ASSERT(val == LONG_MAX - 1); 285 286 /* LONG_MAX */ 287 generate_string(str, sizeof(str), LONG_MAX, 0); 288 val = spdk_strtol(str, 10); 289 CU_ASSERT(val == LONG_MAX); 290 291 /* LONG_MAX + 1 */ 292 generate_string(str, sizeof(str), LONG_MAX, +1); 293 val = spdk_strtol(str, 10); 294 CU_ASSERT(val == -ERANGE); 295 296 val = spdk_strtol(val8, 10); 297 CU_ASSERT(val == -EINVAL); 298 299 val = spdk_strtol(val9, 10); 300 CU_ASSERT(val == -EINVAL); 301 302 val = spdk_strtol(val10, 10); 303 CU_ASSERT(val == 0); 304 305 /* Invalid base */ 306 val = spdk_strtol(val10, 1); 307 CU_ASSERT(val == -EINVAL); 308 309 val = spdk_strtol(val11, 10); 310 CU_ASSERT(val == 0); 311 } 312 313 static void 314 test_strtoll(void) 315 { 316 long long int val; 317 char str[256]; 318 319 const char *val1 = "no_digits"; 320 /* digits + chars */ 321 const char *val8 = "10_is_ten"; 322 /* chars + digits */ 323 const char *val9 = "ten_is_10"; 324 /* all zeroes */ 325 const char *val10 = "00000000"; 326 /* leading minus sign, but not negative */ 327 const char *val11 = "-0"; 328 329 val = spdk_strtoll(val1, 10); 330 CU_ASSERT(val == -EINVAL); 331 332 /* LLONG_MIN - 1 */ 333 generate_string(str, sizeof(str), LLONG_MIN, -1); 334 val = spdk_strtoll(str, 10); 335 CU_ASSERT(val == -ERANGE); 336 337 /* LLONG_MIN */ 338 generate_string(str, sizeof(str), LLONG_MIN, 0); 339 val = spdk_strtoll(str, 10); 340 CU_ASSERT(val == -ERANGE); 341 342 /* LLONG_MIN + 1 */ 343 generate_string(str, sizeof(str), LLONG_MIN, +1); 344 val = spdk_strtoll(str, 10); 345 CU_ASSERT(val == -ERANGE); 346 347 /* LLONG_MAX - 1 */ 348 generate_string(str, sizeof(str), LLONG_MAX, -1); 349 val = spdk_strtoll(str, 10); 350 CU_ASSERT(val == LLONG_MAX - 1); 351 352 /* LLONG_MAX */ 353 generate_string(str, sizeof(str), LLONG_MAX, 0); 354 val = spdk_strtoll(str, 10); 355 CU_ASSERT(val == LLONG_MAX); 356 357 /* LLONG_MAX + 1 */ 358 generate_string(str, sizeof(str), LLONG_MAX, +1); 359 val = spdk_strtoll(str, 10); 360 CU_ASSERT(val == -ERANGE); 361 362 val = spdk_strtoll(val8, 10); 363 CU_ASSERT(val == -EINVAL); 364 365 val = spdk_strtoll(val9, 10); 366 CU_ASSERT(val == -EINVAL); 367 368 val = spdk_strtoll(val10, 10); 369 CU_ASSERT(val == 0); 370 371 /* Invalid base */ 372 val = spdk_strtoll(val10, 1); 373 CU_ASSERT(val == -EINVAL); 374 375 val = spdk_strtoll(val11, 10); 376 CU_ASSERT(val == 0); 377 } 378 379 static void 380 test_strarray(void) 381 { 382 char **r; 383 char **r2; 384 385 r = spdk_strarray_from_string("", ":"); 386 CU_ASSERT(strcmp(r[0], "") == 0); 387 CU_ASSERT(r[1] == NULL); 388 spdk_strarray_free(r); 389 390 r = spdk_strarray_from_string(":", ":"); 391 CU_ASSERT(strcmp(r[0], "") == 0); 392 CU_ASSERT(strcmp(r[1], "") == 0); 393 CU_ASSERT(r[2] == NULL); 394 spdk_strarray_free(r); 395 396 r = spdk_strarray_from_string("a", ":"); 397 CU_ASSERT(strcmp(r[0], "a") == 0); 398 CU_ASSERT(r[1] == NULL); 399 spdk_strarray_free(r); 400 401 r = spdk_strarray_from_string("ab:", ":"); 402 CU_ASSERT(strcmp(r[0], "ab") == 0); 403 CU_ASSERT(strcmp(r[1], "") == 0); 404 CU_ASSERT(r[2] == NULL); 405 spdk_strarray_free(r); 406 407 r = spdk_strarray_from_string(":ab", ":"); 408 CU_ASSERT(strcmp(r[0], "") == 0); 409 CU_ASSERT(strcmp(r[1], "ab") == 0); 410 CU_ASSERT(r[2] == NULL); 411 spdk_strarray_free(r); 412 413 r = spdk_strarray_from_string("ab:c", ":"); 414 CU_ASSERT(strcmp(r[0], "ab") == 0); 415 CU_ASSERT(strcmp(r[1], "c") == 0); 416 CU_ASSERT(r[2] == NULL); 417 spdk_strarray_free(r); 418 419 r = spdk_strarray_from_string(":ab.:c:", ":."); 420 CU_ASSERT(strcmp(r[0], "") == 0); 421 CU_ASSERT(strcmp(r[1], "ab") == 0); 422 CU_ASSERT(strcmp(r[2], "") == 0); 423 CU_ASSERT(strcmp(r[3], "c") == 0); 424 CU_ASSERT(strcmp(r[4], "") == 0); 425 CU_ASSERT(r[5] == NULL); 426 spdk_strarray_free(r); 427 428 r = spdk_strarray_from_string(":ab.:c:", ":."); 429 r2 = spdk_strarray_dup((const char **)r); 430 CU_ASSERT(strcmp(r2[0], "") == 0); 431 CU_ASSERT(strcmp(r2[1], "ab") == 0); 432 CU_ASSERT(strcmp(r2[2], "") == 0); 433 CU_ASSERT(strcmp(r2[3], "c") == 0); 434 CU_ASSERT(strcmp(r2[4], "") == 0); 435 CU_ASSERT(r2[5] == NULL); 436 spdk_strarray_free(r); 437 spdk_strarray_free(r2); 438 } 439 440 static void 441 test_strcpy_replace(void) 442 { 443 const char *original = "good morning, hello, thank you"; 444 const char *search1 = "evening"; 445 const char *replace1 = "unexpected"; 446 const char *search2 = "morning"; 447 const char *replace2 = "afternoon"; 448 const char *expected2 = "good afternoon, hello, thank you"; 449 const char *search3 = "morning"; 450 const char *replace3 = "night"; 451 const char *expected3 = "good night, hello, thank you"; 452 const char *search4 = "hello"; 453 const char *replace4 = "good bye"; 454 const char *expected4 = "good morning, good bye, thank you"; 455 const char *search5 = "thank you"; 456 const char *replace5 = "you are welcome"; 457 const char *expected5 = "good morning, hello, you are welcome"; 458 const char *search6 = " "; 459 const char *replace6 = "-"; 460 const char *expected6 = "good-morning,-hello,-thank-you"; 461 const char *search7 = ","; 462 const char *replace7 = "."; 463 const char *expected7 = "good morning. hello. thank you"; 464 char result[256]; 465 int rc; 466 467 rc = spdk_strcpy_replace(NULL, 0, NULL, NULL, NULL); 468 CU_ASSERT(rc == -EINVAL); 469 470 rc = spdk_strcpy_replace(result, sizeof(result), original, search1, replace1); 471 CU_ASSERT(rc == 0); 472 CU_ASSERT(strcmp(result, original) == 0); 473 474 rc = spdk_strcpy_replace(result, sizeof(result), original, search2, replace2); 475 CU_ASSERT(rc == 0); 476 CU_ASSERT(strcmp(result, expected2) == 0); 477 478 /* A case that sizeof(replace) is less than sizeof(search), and the result array is 479 * smaller than the original string. */ 480 rc = spdk_strcpy_replace(result, strlen(expected3) + 1, original, search3, replace3); 481 CU_ASSERT(rc == 0); 482 CU_ASSERT(strcmp(result, expected3) == 0); 483 484 /* An error case that the result array is smaller than the string with replaced values 485 * and a terminated null byte. */ 486 rc = spdk_strcpy_replace(result, strlen(expected3), original, search3, replace3); 487 CU_ASSERT(rc == -EINVAL); 488 489 rc = spdk_strcpy_replace(result, sizeof(result), original, search4, replace4); 490 CU_ASSERT(rc == 0); 491 CU_ASSERT(strcmp(result, expected4) == 0); 492 493 rc = spdk_strcpy_replace(result, sizeof(result), original, search5, replace5); 494 CU_ASSERT(rc == 0); 495 CU_ASSERT(strcmp(result, expected5) == 0); 496 497 rc = spdk_strcpy_replace(result, sizeof(result), original, search6, replace6); 498 CU_ASSERT(rc == 0); 499 CU_ASSERT(strcmp(result, expected6) == 0); 500 501 rc = spdk_strcpy_replace(result, sizeof(result), original, search7, replace7); 502 CU_ASSERT(rc == 0); 503 CU_ASSERT(strcmp(result, expected7) == 0); 504 } 505 506 int 507 main(int argc, char **argv) 508 { 509 CU_pSuite suite = NULL; 510 unsigned int num_failures; 511 512 CU_initialize_registry(); 513 514 suite = CU_add_suite("string", NULL, NULL); 515 516 CU_ADD_TEST(suite, test_parse_ip_addr); 517 CU_ADD_TEST(suite, test_str_chomp); 518 CU_ADD_TEST(suite, test_parse_capacity); 519 CU_ADD_TEST(suite, test_sprintf_append_realloc); 520 CU_ADD_TEST(suite, test_strtol); 521 CU_ADD_TEST(suite, test_strtoll); 522 CU_ADD_TEST(suite, test_strarray); 523 CU_ADD_TEST(suite, test_strcpy_replace); 524 525 526 num_failures = spdk_ut_run_tests(argc, argv, NULL); 527 528 CU_cleanup_registry(); 529 530 return num_failures; 531 } 532