1 /*- 2 * BSD LICENSE 3 * 4 * Copyright (c) Intel Corporation. 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * * Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * * Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * * Neither the name of Intel Corporation nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 24 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 25 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 26 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 27 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 28 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 29 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 30 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 31 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 32 */ 33 34 #include "spdk/stdinc.h" 35 36 #include "spdk_cunit.h" 37 38 #include "util/string.c" 39 40 static void 41 test_parse_ip_addr(void) 42 { 43 int rc; 44 char *host; 45 char *port; 46 char ip[255]; 47 48 /* IPv4 */ 49 snprintf(ip, 255, "%s", "192.168.0.1"); 50 rc = spdk_parse_ip_addr(ip, &host, &port); 51 CU_ASSERT_EQUAL(rc, 0); 52 SPDK_CU_ASSERT_FATAL(host != NULL); 53 CU_ASSERT(strcmp(host, "192.168.0.1") == 0); 54 CU_ASSERT_EQUAL(strlen(host), 11); 55 CU_ASSERT_EQUAL(port, NULL); 56 57 /* IPv4 with port */ 58 snprintf(ip, 255, "%s", "123.456.789.0:5520"); 59 rc = spdk_parse_ip_addr(ip, &host, &port); 60 CU_ASSERT_EQUAL(rc, 0); 61 SPDK_CU_ASSERT_FATAL(host != NULL); 62 CU_ASSERT(strcmp(host, "123.456.789.0") == 0); 63 CU_ASSERT_EQUAL(strlen(host), 13); 64 SPDK_CU_ASSERT_FATAL(port != NULL); 65 CU_ASSERT(strcmp(port, "5520") == 0); 66 CU_ASSERT_EQUAL(strlen(port), 4); 67 68 /* IPv6 */ 69 snprintf(ip, 255, "%s", "[2001:db8:85a3:8d3:1319:8a2e:370:7348]"); 70 rc = spdk_parse_ip_addr(ip, &host, &port); 71 CU_ASSERT_EQUAL(rc, 0); 72 SPDK_CU_ASSERT_FATAL(host != NULL); 73 CU_ASSERT(strcmp(host, "2001:db8:85a3:8d3:1319:8a2e:370:7348") == 0); 74 CU_ASSERT_EQUAL(strlen(host), 36); 75 CU_ASSERT_EQUAL(port, NULL); 76 77 /* IPv6 with port */ 78 snprintf(ip, 255, "%s", "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:443"); 79 rc = spdk_parse_ip_addr(ip, &host, &port); 80 CU_ASSERT_EQUAL(rc, 0); 81 SPDK_CU_ASSERT_FATAL(host != NULL); 82 CU_ASSERT(strcmp(host, "2001:db8:85a3:8d3:1319:8a2e:370:7348") == 0); 83 CU_ASSERT_EQUAL(strlen(host), 36); 84 SPDK_CU_ASSERT_FATAL(port != NULL); 85 CU_ASSERT(strcmp(port, "443") == 0); 86 CU_ASSERT_EQUAL(strlen(port), 3); 87 88 /* IPv6 dangling colon */ 89 snprintf(ip, 255, "%s", "[2001:db8:85a3:8d3:1319:8a2e:370:7348]:"); 90 rc = spdk_parse_ip_addr(ip, &host, &port); 91 CU_ASSERT_EQUAL(rc, 0); 92 SPDK_CU_ASSERT_FATAL(host != NULL); 93 CU_ASSERT(strcmp(host, "2001:db8:85a3:8d3:1319:8a2e:370:7348") == 0); 94 CU_ASSERT_EQUAL(strlen(host), 36); 95 CU_ASSERT_EQUAL(port, NULL); 96 } 97 98 static void 99 test_str_chomp(void) 100 { 101 char s[1024]; 102 103 /* One \n newline */ 104 snprintf(s, sizeof(s), "%s", "hello world\n"); 105 CU_ASSERT(spdk_str_chomp(s) == 1); 106 CU_ASSERT(strcmp(s, "hello world") == 0); 107 108 /* One \r\n newline */ 109 snprintf(s, sizeof(s), "%s", "hello world\r\n"); 110 CU_ASSERT(spdk_str_chomp(s) == 2); 111 CU_ASSERT(strcmp(s, "hello world") == 0); 112 113 /* No newlines */ 114 snprintf(s, sizeof(s), "%s", "hello world"); 115 CU_ASSERT(spdk_str_chomp(s) == 0); 116 CU_ASSERT(strcmp(s, "hello world") == 0); 117 118 /* Two newlines */ 119 snprintf(s, sizeof(s), "%s", "hello world\n\n"); 120 CU_ASSERT(spdk_str_chomp(s) == 2); 121 CU_ASSERT(strcmp(s, "hello world") == 0); 122 123 /* Empty string */ 124 snprintf(s, sizeof(s), "%s", ""); 125 CU_ASSERT(spdk_str_chomp(s) == 0); 126 CU_ASSERT(strcmp(s, "") == 0); 127 128 /* One-character string with only \n */ 129 snprintf(s, sizeof(s), "%s", "\n"); 130 CU_ASSERT(spdk_str_chomp(s) == 1); 131 CU_ASSERT(strcmp(s, "") == 0); 132 133 /* One-character string without a newline */ 134 snprintf(s, sizeof(s), "%s", "a"); 135 CU_ASSERT(spdk_str_chomp(s) == 0); 136 CU_ASSERT(strcmp(s, "a") == 0); 137 } 138 139 static void 140 test_parse_capacity(void) 141 { 142 char str[128]; 143 uint64_t cap; 144 int rc; 145 bool has_prefix = true; 146 147 rc = spdk_parse_capacity("472", &cap, &has_prefix); 148 CU_ASSERT(rc == 0); 149 CU_ASSERT(cap == 472); 150 CU_ASSERT(has_prefix == false); 151 152 snprintf(str, sizeof(str), "%"PRIu64, UINT64_MAX); 153 rc = spdk_parse_capacity(str, &cap, &has_prefix); 154 CU_ASSERT(rc == 0); 155 CU_ASSERT(cap == UINT64_MAX); 156 CU_ASSERT(has_prefix == false); 157 158 rc = spdk_parse_capacity("12k", &cap, &has_prefix); 159 CU_ASSERT(rc == 0); 160 CU_ASSERT(cap == 12 * 1024); 161 CU_ASSERT(has_prefix == true); 162 163 rc = spdk_parse_capacity("12K", &cap, &has_prefix); 164 CU_ASSERT(rc == 0); 165 CU_ASSERT(cap == 12 * 1024); 166 CU_ASSERT(has_prefix == true); 167 168 rc = spdk_parse_capacity("12KB", &cap, &has_prefix); 169 CU_ASSERT(rc == 0); 170 CU_ASSERT(cap == 12 * 1024); 171 CU_ASSERT(has_prefix == true); 172 173 rc = spdk_parse_capacity("100M", &cap, &has_prefix); 174 CU_ASSERT(rc == 0); 175 CU_ASSERT(cap == 100 * 1024 * 1024); 176 CU_ASSERT(has_prefix == true); 177 178 rc = spdk_parse_capacity("128M", &cap, &has_prefix); 179 CU_ASSERT(rc == 0); 180 CU_ASSERT(cap == 128 * 1024 * 1024); 181 CU_ASSERT(has_prefix == true); 182 183 rc = spdk_parse_capacity("4G", &cap, &has_prefix); 184 CU_ASSERT(rc == 0); 185 CU_ASSERT(cap == 4ULL * 1024 * 1024 * 1024); 186 CU_ASSERT(has_prefix == true); 187 188 rc = spdk_parse_capacity("100M 512k", &cap, &has_prefix); 189 CU_ASSERT(rc == 0); 190 CU_ASSERT(cap == 100ULL * 1024 * 1024); 191 192 rc = spdk_parse_capacity("12k8K", &cap, &has_prefix); 193 CU_ASSERT(rc == 0); 194 CU_ASSERT(cap == 12 * 1024); 195 CU_ASSERT(has_prefix == true); 196 197 /* Non-number */ 198 rc = spdk_parse_capacity("G", &cap, &has_prefix); 199 CU_ASSERT(rc != 0); 200 201 rc = spdk_parse_capacity("darsto", &cap, &has_prefix); 202 CU_ASSERT(rc != 0); 203 } 204 205 static void 206 test_sprintf_append_realloc(void) 207 { 208 char *str1, *str2, *str3, *str4; 209 210 /* Test basic functionality. */ 211 str1 = spdk_sprintf_alloc("hello world\ngood morning\n" \ 212 "good afternoon\ngood evening\n"); 213 SPDK_CU_ASSERT_FATAL(str1 != NULL); 214 215 str2 = spdk_sprintf_append_realloc(NULL, "hello world\n"); 216 SPDK_CU_ASSERT_FATAL(str2); 217 218 str2 = spdk_sprintf_append_realloc(str2, "good morning\n"); 219 SPDK_CU_ASSERT_FATAL(str2); 220 221 str2 = spdk_sprintf_append_realloc(str2, "good afternoon\n"); 222 SPDK_CU_ASSERT_FATAL(str2); 223 224 str2 = spdk_sprintf_append_realloc(str2, "good evening\n"); 225 SPDK_CU_ASSERT_FATAL(str2); 226 227 CU_ASSERT(strcmp(str1, str2) == 0); 228 229 free(str1); 230 free(str2); 231 232 /* Test doubling buffer size. */ 233 str3 = spdk_sprintf_append_realloc(NULL, "aaaaaaaaaa\n"); 234 str3 = spdk_sprintf_append_realloc(str3, "bbbbbbbbbb\n"); 235 str3 = spdk_sprintf_append_realloc(str3, "cccccccccc\n"); 236 237 str4 = malloc(33 + 1); 238 memset(&str4[0], 'a', 10); 239 str4[10] = '\n'; 240 memset(&str4[11], 'b', 10); 241 str4[21] = '\n'; 242 memset(&str4[22], 'c', 10); 243 str4[32] = '\n'; 244 str4[33] = 0; 245 246 CU_ASSERT(strcmp(str3, str4) == 0); 247 248 free(str3); 249 free(str4); 250 } 251 static void 252 test_strtol(void) 253 { 254 long int val; 255 256 const char *val1 = "no_digits"; 257 /* LLONG_MIN - 1 */ 258 const char *val2 = "-9223372036854775809"; 259 /* LONG_MIN */ 260 const char *val3 = "-9223372036854775808"; 261 /* LONG_MIN + 1 */ 262 const char *val4 = "-9223372036854775807"; 263 /* LONG_MAX - 1 */ 264 const char *val5 = "9223372036854775806"; 265 /* LONG_MAX */ 266 const char *val6 = "9223372036854775807"; 267 /* LONG_MAX + 1 */ 268 const char *val7 = "9223372036854775808"; 269 /* digits + chars */ 270 const char *val8 = "10_is_ten"; 271 /* chars + digits */ 272 const char *val9 = "ten_is_10"; 273 /* all zeroes */ 274 const char *val10 = "00000000"; 275 /* leading minus sign, but not negative */ 276 const char *val11 = "-0"; 277 278 val = spdk_strtol(val1, 10); 279 CU_ASSERT(val == -EINVAL); 280 281 val = spdk_strtol(val2, 10); 282 CU_ASSERT(val == -ERANGE); 283 284 val = spdk_strtol(val3, 10); 285 CU_ASSERT(val == -ERANGE); 286 287 val = spdk_strtol(val4, 10); 288 CU_ASSERT(val == -ERANGE); 289 290 val = spdk_strtol(val5, 10); 291 CU_ASSERT(val == LONG_MAX - 1); 292 293 val = spdk_strtol(val6, 10); 294 CU_ASSERT(val == LONG_MAX); 295 296 val = spdk_strtol(val7, 10); 297 CU_ASSERT(val == -ERANGE); 298 299 val = spdk_strtol(val8, 10); 300 CU_ASSERT(val == -EINVAL); 301 302 val = spdk_strtol(val9, 10); 303 CU_ASSERT(val == -EINVAL); 304 305 val = spdk_strtol(val10, 10); 306 CU_ASSERT(val == 0); 307 308 /* Invalid base */ 309 val = spdk_strtol(val10, 1); 310 CU_ASSERT(val == -EINVAL); 311 312 val = spdk_strtol(val11, 10); 313 CU_ASSERT(val == 0); 314 } 315 316 static void 317 test_strtoll(void) 318 { 319 long long int val; 320 321 const char *val1 = "no_digits"; 322 /* LLONG_MIN - 1 */ 323 const char *val2 = "-9223372036854775809"; 324 /* LLONG_MIN */ 325 const char *val3 = "-9223372036854775808"; 326 /* LLONG_MIN + 1 */ 327 const char *val4 = "-9223372036854775807"; 328 /* LLONG_MAX - 1 */ 329 const char *val5 = "9223372036854775806"; 330 /* LLONG_MAX */ 331 const char *val6 = "9223372036854775807"; 332 /* LLONG_MAX + 1 */ 333 const char *val7 = "9223372036854775808"; 334 /* digits + chars */ 335 const char *val8 = "10_is_ten"; 336 /* chars + digits */ 337 const char *val9 = "ten_is_10"; 338 /* all zeroes */ 339 const char *val10 = "00000000"; 340 /* leading minus sign, but not negative */ 341 const char *val11 = "-0"; 342 343 val = spdk_strtoll(val1, 10); 344 CU_ASSERT(val == -EINVAL); 345 346 val = spdk_strtoll(val2, 10); 347 CU_ASSERT(val == -ERANGE); 348 349 val = spdk_strtoll(val3, 10); 350 CU_ASSERT(val == -ERANGE); 351 352 val = spdk_strtoll(val4, 10); 353 CU_ASSERT(val == -ERANGE); 354 355 val = spdk_strtoll(val5, 10); 356 CU_ASSERT(val == LLONG_MAX - 1); 357 358 val = spdk_strtoll(val6, 10); 359 CU_ASSERT(val == LLONG_MAX); 360 361 val = spdk_strtoll(val7, 10); 362 CU_ASSERT(val == -ERANGE); 363 364 val = spdk_strtoll(val8, 10); 365 CU_ASSERT(val == -EINVAL); 366 367 val = spdk_strtoll(val9, 10); 368 CU_ASSERT(val == -EINVAL); 369 370 val = spdk_strtoll(val10, 10); 371 CU_ASSERT(val == 0); 372 373 /* Invalid base */ 374 val = spdk_strtoll(val10, 1); 375 CU_ASSERT(val == -EINVAL); 376 377 val = spdk_strtoll(val11, 10); 378 CU_ASSERT(val == 0); 379 } 380 381 int 382 main(int argc, char **argv) 383 { 384 CU_pSuite suite = NULL; 385 unsigned int num_failures; 386 387 if (CU_initialize_registry() != CUE_SUCCESS) { 388 return CU_get_error(); 389 } 390 391 suite = CU_add_suite("string", NULL, NULL); 392 if (suite == NULL) { 393 CU_cleanup_registry(); 394 return CU_get_error(); 395 } 396 397 if ( 398 CU_add_test(suite, "test_parse_ip_addr", test_parse_ip_addr) == NULL || 399 CU_add_test(suite, "test_str_chomp", test_str_chomp) == NULL || 400 CU_add_test(suite, "test_parse_capacity", test_parse_capacity) == NULL || 401 CU_add_test(suite, "test_sprintf_append_realloc", test_sprintf_append_realloc) == NULL || 402 CU_add_test(suite, "test_strtol", test_strtol) == NULL || 403 CU_add_test(suite, "test_strtoll", test_strtoll) == NULL) { 404 CU_cleanup_registry(); 405 return CU_get_error(); 406 } 407 408 CU_basic_set_mode(CU_BRM_VERBOSE); 409 410 CU_basic_run_tests(); 411 412 num_failures = CU_get_number_of_failures(); 413 CU_cleanup_registry(); 414 415 return num_failures; 416 } 417