1 /* 2 * Copyright (c) 2018-2020 The Linux Foundation. All rights reserved. 3 * Copyright (c) 2022 Qualcomm Innovation Center, Inc. All rights reserved. 4 * 5 * Permission to use, copy, modify, and/or distribute this software for 6 * any purpose with or without fee is hereby granted, provided that the 7 * above copyright notice and this permission notice appear in all 8 * copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL 11 * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED 12 * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE 13 * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL 14 * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR 15 * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 16 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR 17 * PERFORMANCE OF THIS SOFTWARE. 18 */ 19 20 #include "qdf_mem.h" 21 #include "qdf_trace.h" 22 #include "qdf_types.h" 23 #include "qdf_types_test.h" 24 25 #define WHITESPACE "\t\n\r \x20" 26 27 #define ut_bool_pass(str, exp) __ut_bool(str, QDF_STATUS_SUCCESS, exp) 28 #define ut_bool_fail(str) __ut_bool(str, QDF_STATUS_E_FAILURE, false) 29 30 static uint32_t 31 __ut_bool(const char *str, QDF_STATUS exp_status, bool exp_value) 32 { 33 bool value; 34 QDF_STATUS status = qdf_bool_parse(str, &value); 35 36 if (status != exp_status) { 37 qdf_nofl_alert("FAIL: qdf_bool_parse(\"%s\") -> status %d; expected status %d", 38 str, status, exp_status); 39 return 1; 40 } 41 42 if (QDF_IS_STATUS_ERROR(status)) 43 return 0; 44 45 if (value != exp_value) { 46 qdf_nofl_alert("FAIL: qdf_bool_parse(\"%s\") -> %s; expected %s", 47 str, value ? "true" : "false", 48 exp_value ? "true" : "false"); 49 return 1; 50 } 51 52 return 0; 53 } 54 55 static uint32_t qdf_types_ut_bool_parse(void) 56 { 57 uint32_t errors = 0; 58 59 errors += ut_bool_pass("1", true); 60 errors += ut_bool_pass("y", true); 61 errors += ut_bool_pass("Y", true); 62 errors += ut_bool_pass("0", false); 63 errors += ut_bool_pass("n", false); 64 errors += ut_bool_pass("N", false); 65 errors += ut_bool_pass(WHITESPACE "1" WHITESPACE, true); 66 67 errors += ut_bool_fail("true"); 68 errors += ut_bool_fail("false"); 69 errors += ut_bool_fail("日本"); 70 71 return errors; 72 } 73 74 #define ut_int32_pass(str, exp) __ut_int32(str, QDF_STATUS_SUCCESS, exp) 75 #define ut_int32_fail(str, exp_status) __ut_int32(str, exp_status, 0) 76 77 static uint32_t 78 __ut_int32(const char *str, QDF_STATUS exp_status, int32_t exp_value) 79 { 80 int32_t value; 81 QDF_STATUS status = qdf_int32_parse(str, &value); 82 83 if (status != exp_status) { 84 qdf_nofl_alert("FAIL: qdf_int32_parse(\"%s\") -> status %d; expected status %d", 85 str, status, exp_status); 86 return 1; 87 } 88 89 if (QDF_IS_STATUS_ERROR(status)) 90 return 0; 91 92 if (value != exp_value) { 93 qdf_nofl_alert("FAIL: qdf_int32_parse(\"%s\") -> %d; expected %d", 94 str, value, exp_value); 95 return 1; 96 } 97 98 return 0; 99 } 100 101 static uint32_t qdf_types_ut_int32_parse(void) 102 { 103 uint32_t errors = 0; 104 105 errors += ut_int32_pass("1", 1); 106 errors += ut_int32_pass("+1", 1); 107 errors += ut_int32_pass("-1", -1); 108 errors += ut_int32_pass(WHITESPACE "1" WHITESPACE, 1); 109 errors += ut_int32_fail("1;", QDF_STATUS_E_FAILURE); 110 errors += ut_int32_pass(" 2147483647", 2147483647); 111 errors += ut_int32_fail(" 2147483648", QDF_STATUS_E_RANGE); 112 errors += ut_int32_pass("-2147483648", -2147483647 - 1); 113 errors += ut_int32_fail("-2147483649", QDF_STATUS_E_RANGE); 114 errors += ut_int32_fail("日本", QDF_STATUS_E_FAILURE); 115 116 return errors; 117 } 118 119 #define ut_int64_pass(str, exp) __ut_int64(str, QDF_STATUS_SUCCESS, exp) 120 #define ut_int64_fail(str, exp_status) __ut_int64(str, exp_status, 0) 121 122 static uint32_t 123 __ut_int64(const char *str, QDF_STATUS exp_status, int64_t exp_value) 124 { 125 int64_t value; 126 QDF_STATUS status = qdf_int64_parse(str, &value); 127 128 if (status != exp_status) { 129 qdf_nofl_alert("FAIL: qdf_int64_parse(\"%s\") -> status %d; expected status %d", 130 str, status, exp_status); 131 return 1; 132 } 133 134 if (QDF_IS_STATUS_ERROR(status)) 135 return 0; 136 137 if (value != exp_value) { 138 qdf_nofl_alert("FAIL: qdf_int64_parse(\"%s\") -> %lld; expected %lld", 139 str, value, exp_value); 140 return 1; 141 } 142 143 return 0; 144 } 145 146 static uint32_t qdf_types_ut_int64_parse(void) 147 { 148 uint32_t errors = 0; 149 150 errors += ut_int64_pass("1", 1); 151 errors += ut_int64_pass("+1", 1); 152 errors += ut_int64_pass("-1", -1); 153 errors += ut_int64_pass(WHITESPACE "1" WHITESPACE, 1); 154 errors += ut_int64_fail("1;", QDF_STATUS_E_FAILURE); 155 errors += ut_int64_pass(" 9223372036854775807", 9223372036854775807ll); 156 errors += ut_int64_fail(" 9223372036854775808", QDF_STATUS_E_RANGE); 157 errors += ut_int64_pass("-9223372036854775808", 158 -9223372036854775807ll - 1); 159 errors += ut_int64_fail("-9223372036854775809", QDF_STATUS_E_RANGE); 160 errors += ut_int64_fail("日本", QDF_STATUS_E_FAILURE); 161 162 return errors; 163 } 164 165 #define ut_uint16_array_pass(str, max_size, exp_arr, exp_arr_size) \ 166 __ut_uint16_array(str, QDF_STATUS_SUCCESS, max_size, exp_arr, exp_arr_size) 167 168 #define ut_uint16_array_fail(str, max_size, exp_status, exp_arr, exp_arr_size)\ 169 __ut_uint16_array(str, exp_status, max_size, exp_arr, exp_arr_size) 170 171 static uint32_t 172 __ut_uint16_array(const char *str, QDF_STATUS exp_status, 173 uint8_t max_array_size, uint16_t *exp_array, 174 uint8_t exp_array_size) 175 { 176 uint16_t parsed_array[10]; 177 qdf_size_t parsed_array_size; 178 QDF_STATUS status; 179 uint8_t i; 180 181 status = qdf_uint16_array_parse(str, parsed_array, max_array_size, 182 &parsed_array_size); 183 184 if (status != exp_status) { 185 qdf_nofl_alert("FAIL: qdf_uint16_array_parse(\"%s\") -> status %d; expected status %d", 186 str, status, exp_status); 187 return 1; 188 } 189 190 if (QDF_IS_STATUS_ERROR(status)) 191 return 0; 192 193 if (parsed_array_size != exp_array_size) { 194 qdf_nofl_alert("FAIL: qdf_uint16_array_parse(\"%s\") -> parsed_array_size %zu; exp_array_size %d", 195 str, parsed_array_size, exp_array_size); 196 return 1; 197 } 198 199 for (i = 0; i < exp_array_size; i++) 200 if (parsed_array[i] != exp_array[i]) { 201 qdf_nofl_alert("FAIL: qdf_uint16_array_parse(\"%s\") -> parsed_array[%d] %d; exp_array[%d] %d", 202 str, i, parsed_array[i], i, 203 exp_array[i]); 204 return 1; 205 } 206 207 return 0; 208 } 209 210 static uint32_t qdf_types_ut_uint16_array_parse(void) 211 { 212 uint32_t errors = 0; 213 uint16_t exp_array_value[10] = { 214 1, 10, 2412, 2417, 100, 65535, 0, 5486, 5180, 9999}; 215 216 errors += ut_uint16_array_pass( 217 "1, 10, 2412, 2417, 100, 65535, 0, 5486, 5180, 9999", 218 10, exp_array_value, 10); 219 errors += ut_uint16_array_pass( 220 "+1, +10, +2412, +2417, +100, +65535, 0, +5486, +5180, +9999", 221 10, exp_array_value, 10); 222 errors += ut_uint16_array_fail("1;", 10, QDF_STATUS_E_FAILURE, 223 exp_array_value, 0); 224 /* Out of range test where 65536 is out of range */ 225 errors += ut_uint16_array_fail( 226 "1, 10, 2412, 2417, 100, 65536, 0, 5486, 5180, 9999", 227 10, QDF_STATUS_E_RANGE, exp_array_value, 0); 228 errors += ut_uint16_array_fail( 229 "-1, -10, -2412, -2417, -100, -65535, 0, -5486, -5180, -9999", 230 10, QDF_STATUS_E_RANGE, exp_array_value, 0); 231 errors += ut_uint16_array_fail( 232 "1, 10, 2412, 2417, 100, 日本, 0, 5486, 5180, 9999", 233 10, QDF_STATUS_E_FAILURE, exp_array_value, 0); 234 235 return errors; 236 } 237 238 #define ut_int32_array_pass(str, max_size, exp_arr, exp_arr_size) \ 239 __ut_int32_array(str, QDF_STATUS_SUCCESS, max_size, exp_arr, exp_arr_size) 240 241 #define ut_int32_array_fail(str, max_size, exp_status, exp_arr, exp_arr_size)\ 242 __ut_int32_array(str, exp_status, max_size, exp_arr, exp_arr_size) 243 244 static uint32_t 245 __ut_int32_array(const char *str, QDF_STATUS exp_status, 246 uint8_t max_array_size, uint32_t *exp_array, 247 uint8_t exp_array_size) 248 { 249 uint32_t parsed_array[10]; 250 qdf_size_t parsed_array_size; 251 QDF_STATUS status; 252 uint8_t i; 253 254 status = qdf_int32_array_parse(str, parsed_array, max_array_size, 255 &parsed_array_size); 256 257 if (status != exp_status) { 258 qdf_nofl_alert("FAIL: qdf_int32_array_parse(\"%s\") -> status %d; expected status %d", 259 str, status, exp_status); 260 return 1; 261 } 262 263 if (QDF_IS_STATUS_ERROR(status)) 264 return 0; 265 266 if (parsed_array_size != exp_array_size) { 267 qdf_nofl_alert("FAIL: qdf_int32_array_parse(\"%s\") -> parsed_array_size %zu; exp_array_size %d", 268 str, parsed_array_size, exp_array_size); 269 return 1; 270 } 271 272 for (i = 0; i < exp_array_size; i++) 273 if (parsed_array[i] != exp_array[i]) { 274 qdf_nofl_alert("FAIL: qdf_int32_array_parse(\"%s\") -> parsed_array[%d] %d; exp_array[%d] %d", 275 str, i, parsed_array[i], i, 276 exp_array[i]); 277 return 1; 278 } 279 280 return 0; 281 } 282 283 #define ut_uint32_array_pass(str, max_size, exp_arr, exp_arr_size) \ 284 __ut_uint32_array(str, QDF_STATUS_SUCCESS, max_size, exp_arr, exp_arr_size) 285 286 #define ut_uint32_array_fail(str, max_size, exp_status, exp_arr, exp_arr_size)\ 287 __ut_uint32_array(str, exp_status, max_size, exp_arr, exp_arr_size) 288 289 static uint32_t 290 __ut_uint32_array(const char *str, QDF_STATUS exp_status, 291 uint8_t max_array_size, uint32_t *exp_array, 292 uint8_t exp_array_size) 293 { 294 uint32_t parsed_array[10]; 295 qdf_size_t parsed_array_size; 296 QDF_STATUS status; 297 uint8_t i; 298 299 status = qdf_uint32_array_parse(str, parsed_array, max_array_size, 300 &parsed_array_size); 301 302 if (status != exp_status) { 303 qdf_nofl_alert("FAIL: qdf_uint32_array_parse(\"%s\") -> status %d; expected status %d", 304 str, status, exp_status); 305 return 1; 306 } 307 308 if (QDF_IS_STATUS_ERROR(status)) 309 return 0; 310 311 if (parsed_array_size != exp_array_size) { 312 qdf_nofl_alert("FAIL: qdf_uint32_array_parse(\"%s\") -> parsed_array_size %zu; exp_array_size %d", 313 str, parsed_array_size, exp_array_size); 314 return 1; 315 } 316 317 for (i = 0; i < exp_array_size; i++) 318 if (parsed_array[i] != exp_array[i]) { 319 qdf_nofl_alert("FAIL: qdf_uint32_array_parse(\"%s\") -> parsed_array[%d] %d; exp_array[%d] %d", 320 str, i, parsed_array[i], i, 321 exp_array[i]); 322 return 1; 323 } 324 325 return 0; 326 } 327 328 static uint32_t qdf_types_ut_int32_array_parse(void) 329 { 330 uint32_t errors = 0; 331 uint32_t exp_array_value[10] = { 1, 100, 9997, 899965, 65536, 0, 332 2147483647U, -65536, 333 -899965, -9997}; 334 335 errors += ut_int32_array_pass( 336 "1, 100, 9997, 899965, 65536, 0, 2147483647, -65536, -899965, -9997", 337 10, exp_array_value, 10); 338 errors += ut_int32_array_pass( 339 "+1, +100, +9997, +899965, +65536, 0, +2147483647, -65536, -899965, -9997", 340 10, exp_array_value, 10); 341 errors += ut_int32_array_fail("1;", 10, QDF_STATUS_E_FAILURE, 342 exp_array_value, 0); 343 errors += ut_int32_array_fail( 344 "1, 100, 9997, 899965, 65536, 日本, 2147483647, -65536, -899965, -9997", 345 10, QDF_STATUS_E_FAILURE, exp_array_value, 0); 346 347 return errors; 348 } 349 350 static uint32_t qdf_types_ut_uint32_array_parse(void) 351 { 352 uint32_t errors = 0; 353 uint32_t exp_array_value[10] = { 1, 100, 9997, 899965, 65536, 0, 354 4294967295U, 268435456U, 355 2164184149U, 999999999U}; 356 357 errors += ut_uint32_array_pass( 358 "1, 100, 9997, 899965, 65536, 0, 4294967295, 268435456, 2164184149, 999999999", 359 10, exp_array_value, 10); 360 errors += ut_uint32_array_pass( 361 "+1, +100, +9997, +899965, +65536, 0, +4294967295, +268435456, +2164184149, +999999999", 362 10, exp_array_value, 10); 363 errors += ut_uint32_array_fail("1;", 10, QDF_STATUS_E_FAILURE, 364 exp_array_value, 0); 365 /* Out of range test where 4294967296 is out of range */ 366 errors += ut_uint32_array_fail( 367 "1, 100, 9997, 899965, 65536, 0, 4294967296, 268435456, 2164184149, 999999999", 368 10, QDF_STATUS_E_RANGE, exp_array_value, 0); 369 errors += ut_uint32_array_fail( 370 "-1, -100, -9997, -899965, -65536, 0, -4294967295, -268435456, -2164184149, -999999999", 371 10, QDF_STATUS_E_RANGE, exp_array_value, 0); 372 errors += ut_uint32_array_fail( 373 "1, 100, 9997, 899965, 65536, 日本, 0, 4294967295, 268435456, 999999999", 374 10, QDF_STATUS_E_FAILURE, exp_array_value, 0); 375 376 return errors; 377 } 378 379 #define ut_uint32_pass(str, exp) __ut_uint32(str, QDF_STATUS_SUCCESS, exp) 380 #define ut_uint32_fail(str, exp_status) __ut_uint32(str, exp_status, 0) 381 382 static uint32_t 383 __ut_uint32(const char *str, QDF_STATUS exp_status, uint32_t exp_value) 384 { 385 uint32_t value; 386 QDF_STATUS status = qdf_uint32_parse(str, &value); 387 388 if (status != exp_status) { 389 qdf_nofl_alert("FAIL: qdf_uint32_parse(\"%s\") -> status %d; expected status %d", 390 str, status, exp_status); 391 return 1; 392 } 393 394 if (QDF_IS_STATUS_ERROR(status)) 395 return 0; 396 397 if (value != exp_value) { 398 qdf_nofl_alert("FAIL: qdf_uint32_parse(\"%s\") -> %d; expected %d", 399 str, value, exp_value); 400 return 1; 401 } 402 403 return 0; 404 } 405 406 static uint32_t qdf_types_ut_uint32_parse(void) 407 { 408 uint32_t errors = 0; 409 410 errors += ut_uint32_pass("1", 1); 411 errors += ut_uint32_pass("+1", 1); 412 errors += ut_uint32_pass(WHITESPACE "1" WHITESPACE, 1); 413 errors += ut_uint32_fail("1;", QDF_STATUS_E_FAILURE); 414 errors += ut_uint32_pass("4294967295", 4294967295U); 415 errors += ut_uint32_fail("4294967296", QDF_STATUS_E_RANGE); 416 errors += ut_uint32_pass(" 0", 0); 417 errors += ut_uint32_fail("-1", QDF_STATUS_E_RANGE); 418 errors += ut_uint32_fail("日本", QDF_STATUS_E_FAILURE); 419 420 return errors; 421 } 422 423 #define ut_uint64_pass(str, exp) __ut_uint64(str, QDF_STATUS_SUCCESS, exp) 424 #define ut_uint64_fail(str, exp_status) __ut_uint64(str, exp_status, 0) 425 426 static uint32_t 427 __ut_uint64(const char *str, QDF_STATUS exp_status, uint64_t exp_value) 428 { 429 uint64_t value; 430 QDF_STATUS status = qdf_uint64_parse(str, &value); 431 432 if (status != exp_status) { 433 qdf_nofl_alert("FAIL: qdf_uint64_parse(\"%s\") -> status %d; expected status %d", 434 str, status, exp_status); 435 return 1; 436 } 437 438 if (QDF_IS_STATUS_ERROR(status)) 439 return 0; 440 441 if (value != exp_value) { 442 qdf_nofl_alert("FAIL: qdf_uint64_parse(\"%s\") -> %llu; expected %llu", 443 str, value, exp_value); 444 return 1; 445 } 446 447 return 0; 448 } 449 450 static uint32_t qdf_types_ut_uint64_parse(void) 451 { 452 uint32_t errors = 0; 453 454 errors += ut_uint64_pass("1", 1); 455 errors += ut_uint64_pass("+1", 1); 456 errors += ut_uint64_pass(WHITESPACE "1" WHITESPACE, 1); 457 errors += ut_uint64_fail("1;", QDF_STATUS_E_FAILURE); 458 errors += ut_uint64_pass("18446744073709551615", 459 18446744073709551615ull); 460 errors += ut_uint64_fail("18446744073709551616", QDF_STATUS_E_RANGE); 461 errors += ut_uint64_pass(" 0", 0); 462 errors += ut_uint64_fail("-1", QDF_STATUS_E_RANGE); 463 errors += ut_uint64_fail("日本", QDF_STATUS_E_FAILURE); 464 465 return errors; 466 } 467 468 static uint32_t qdf_types_ut_int_formats_parse(void) 469 { 470 uint32_t errors = 0; 471 472 errors += ut_uint64_pass("0b01", 1); 473 errors += ut_uint64_pass("0o01234567", 342391); 474 errors += ut_uint64_pass("0123456789", 123456789); 475 errors += ut_uint64_pass("0x0123456789abcdef", 81985529216486895ll); 476 477 errors += ut_uint64_fail("0b012", QDF_STATUS_E_FAILURE); 478 errors += ut_uint64_fail("0o012345678", QDF_STATUS_E_FAILURE); 479 errors += ut_uint64_fail("0123456789a", QDF_STATUS_E_FAILURE); 480 errors += ut_uint64_fail("0x0123456789abcdefg", QDF_STATUS_E_FAILURE); 481 482 return errors; 483 } 484 485 #define ut_mac_pass(str, exp) __ut_mac(str, #str, QDF_STATUS_SUCCESS, &(exp)) 486 #define ut_mac_fail(str) __ut_mac(str, #str, QDF_STATUS_E_FAILURE, NULL) 487 488 static uint32_t 489 __ut_mac(const char *str, const char *display_str, QDF_STATUS exp_status, 490 struct qdf_mac_addr *exp_value) 491 { 492 struct qdf_mac_addr value; 493 QDF_STATUS status = qdf_mac_parse(str, &value); 494 495 if (status != exp_status) { 496 qdf_nofl_alert("FAIL: qdf_mac_parse(%s) -> status %d; expected status %d", 497 display_str, status, exp_status); 498 return 1; 499 } 500 501 if (QDF_IS_STATUS_ERROR(status)) 502 return 0; 503 504 if (qdf_mem_cmp(&value, exp_value, sizeof(value))) { 505 qdf_nofl_alert("FAIL: qdf_mac_parse(%s) -> " QDF_FULL_MAC_FMT 506 "; expected " QDF_FULL_MAC_FMT, 507 display_str, 508 QDF_FULL_MAC_REF(value.bytes), 509 QDF_FULL_MAC_REF(exp_value->bytes)); 510 return 1; 511 } 512 513 return 0; 514 } 515 516 static uint32_t qdf_types_ut_mac_parse(void) 517 { 518 uint32_t errors = 0; 519 struct qdf_mac_addr addr_aabbccddeeff = { { 520 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff } }; 521 struct qdf_mac_addr addr_0123456789ab = { { 522 0x01, 0x23, 0x45, 0x67, 0x89, 0xab } }; 523 524 errors += ut_mac_fail(""); 525 errors += ut_mac_fail("test"); 526 errors += ut_mac_fail("¥円"); 527 errors += ut_mac_pass("aabbccddeeff", addr_aabbccddeeff); 528 errors += ut_mac_pass("AABBCCDDEEFF", addr_aabbccddeeff); 529 errors += ut_mac_fail("aa:bbccddeeff"); 530 errors += ut_mac_fail("aabbccddee:ff"); 531 errors += ut_mac_pass("aa:bb:cc:dd:ee:ff", addr_aabbccddeeff); 532 errors += ut_mac_pass("01:23:45:67:89:ab", addr_0123456789ab); 533 errors += ut_mac_fail("01:23:45:67:89:ab:cd:ef"); 534 errors += ut_mac_fail("01:23:45\0:67:89:ab"); 535 errors += ut_mac_pass(WHITESPACE "01:23:45:67:89:ab" WHITESPACE, 536 addr_0123456789ab); 537 errors += ut_mac_pass("01:23:45:67:89:ab\n", addr_0123456789ab); 538 errors += ut_mac_fail("01:23:45:67:89:ab\t ,"); 539 540 return errors; 541 } 542 543 #define ut_ipv4_pass(str, exp) __ut_ipv4(str, #str, QDF_STATUS_SUCCESS, &(exp)) 544 #define ut_ipv4_fail(str) __ut_ipv4(str, #str, QDF_STATUS_E_FAILURE, NULL) 545 546 static uint32_t 547 __ut_ipv4(const char *str, const char *display_str, QDF_STATUS exp_status, 548 struct qdf_ipv4_addr *exp_value) 549 { 550 struct qdf_ipv4_addr value; 551 QDF_STATUS status = qdf_ipv4_parse(str, &value); 552 553 if (status != exp_status) { 554 qdf_nofl_alert("FAIL: qdf_ipv4_parse(%s) -> status %d; expected status %d", 555 display_str, status, exp_status); 556 return 1; 557 } 558 559 if (QDF_IS_STATUS_ERROR(status)) 560 return 0; 561 562 if (qdf_mem_cmp(&value, exp_value, sizeof(value))) { 563 qdf_nofl_alert("FAIL: qdf_ipv4_parse(%s) -> " QDF_IPV4_ADDR_STR 564 "; expected " QDF_IPV4_ADDR_STR, 565 display_str, 566 QDF_IPV4_ADDR_ARRAY(value.bytes), 567 QDF_IPV4_ADDR_ARRAY(exp_value->bytes)); 568 return 1; 569 } 570 571 return 0; 572 } 573 574 static uint32_t qdf_types_ut_ipv4_parse(void) 575 { 576 uint32_t errors = 0; 577 struct qdf_ipv4_addr addr_0000 = { { 0, 0, 0, 0 } }; 578 struct qdf_ipv4_addr addr_127001 = { { 127, 0, 0, 1 } }; 579 struct qdf_ipv4_addr addr_0112123 = { { 0, 1, 12, 123 } }; 580 struct qdf_ipv4_addr addr_255255255255 = { { 255, 255, 255, 255 } }; 581 582 errors += ut_ipv4_fail(""); 583 errors += ut_ipv4_fail("test"); 584 errors += ut_ipv4_fail("¥円"); 585 errors += ut_ipv4_pass("0.0.0.0", addr_0000); 586 errors += ut_ipv4_pass("127.0.0.1", addr_127001); 587 errors += ut_ipv4_pass("255.255.255.255", addr_255255255255); 588 errors += ut_ipv4_fail(".0.0.1"); 589 errors += ut_ipv4_fail("127.0.0."); 590 errors += ut_ipv4_fail("abc.123.123.123"); 591 errors += ut_ipv4_fail("256.0.0.0"); 592 errors += ut_ipv4_pass("0.1.12.123", addr_0112123); 593 errors += ut_ipv4_pass(WHITESPACE "0.1.12.123" WHITESPACE, 594 addr_0112123); 595 errors += ut_ipv4_fail("0.1.12\0.123"); 596 errors += ut_ipv4_fail("0.1.12.123 ,"); 597 598 return errors; 599 } 600 601 #define ut_ipv6_pass(str, exp) __ut_ipv6(str, #str, QDF_STATUS_SUCCESS, &(exp)) 602 #define ut_ipv6_fail(str) __ut_ipv6(str, #str, QDF_STATUS_E_FAILURE, NULL) 603 604 static uint32_t 605 __ut_ipv6(const char *str, const char *display_str, QDF_STATUS exp_status, 606 struct qdf_ipv6_addr *exp_value) 607 { 608 struct qdf_ipv6_addr value; 609 QDF_STATUS status = qdf_ipv6_parse(str, &value); 610 611 if (status != exp_status) { 612 qdf_nofl_alert("FAIL: qdf_ipv6_parse(%s) -> status %d; expected status %d", 613 display_str, status, exp_status); 614 return 1; 615 } 616 617 if (QDF_IS_STATUS_ERROR(status)) 618 return 0; 619 620 if (qdf_mem_cmp(&value, exp_value, sizeof(value))) { 621 qdf_nofl_alert("FAIL: qdf_ipv6_parse(%s) -> " QDF_IPV6_ADDR_STR 622 "; expected " QDF_IPV6_ADDR_STR, 623 display_str, 624 QDF_IPV6_ADDR_ARRAY(value.bytes), 625 QDF_IPV6_ADDR_ARRAY(exp_value->bytes)); 626 return 1; 627 } 628 629 return 0; 630 } 631 632 static uint32_t qdf_types_ut_ipv6_parse(void) 633 { 634 uint32_t errors = 0; 635 struct qdf_ipv6_addr addr_00000000000000000000000000000000 = { { 636 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 637 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 638 } }; 639 struct qdf_ipv6_addr addr_00000000000000000000000000000001 = { { 640 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 641 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 642 } }; 643 struct qdf_ipv6_addr addr_00010000000000000000000000000000 = { { 644 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 645 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 646 } }; 647 struct qdf_ipv6_addr addr_0123456789abcdefabcdef0123456789 = { { 648 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef, 649 0xab, 0xcd, 0xef, 0x01, 0x23, 0x45, 0x67, 0x89, 650 } }; 651 struct qdf_ipv6_addr addr_20010db885a3000000008a2e03707334 = { { 652 0x20, 0x01, 0x0d, 0xb8, 0x85, 0xa3, 0x00, 0x00, 653 0x00, 0x00, 0x8a, 0x2e, 0x03, 0x70, 0x73, 0x34, 654 } }; 655 struct qdf_ipv6_addr addr_ff020000000000000000000000000001 = { { 656 0xff, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 657 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 658 } }; 659 struct qdf_ipv6_addr addr_00000000000000000000ffffc0000280 = { { 660 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 661 0x00, 0x00, 0xff, 0xff, 0xc0, 0x00, 0x02, 0x80, 662 } }; 663 struct qdf_ipv6_addr addr_00010000000000000000000000000001 = { { 664 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 665 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 666 } }; 667 668 errors += ut_ipv6_fail(""); 669 errors += ut_ipv6_fail("test"); 670 errors += ut_ipv6_fail("¥円"); 671 errors += ut_ipv6_pass("::", 672 addr_00000000000000000000000000000000); 673 errors += ut_ipv6_pass("::0", 674 addr_00000000000000000000000000000000); 675 errors += ut_ipv6_pass("0:0:0:0:0:0:0:0", 676 addr_00000000000000000000000000000000); 677 errors += ut_ipv6_pass("::1", 678 addr_00000000000000000000000000000001); 679 errors += ut_ipv6_pass("1::", 680 addr_00010000000000000000000000000000); 681 errors += ut_ipv6_pass("0:0:0:0:0:0:0:1", 682 addr_00000000000000000000000000000001); 683 errors += ut_ipv6_pass("0123:4567:89ab:cdef:ABCD:EF01:2345:6789", 684 addr_0123456789abcdefabcdef0123456789); 685 errors += ut_ipv6_fail("::0123:4567:89ab:cdef:ABCD:EF01:2345:6789"); 686 errors += ut_ipv6_fail("0123:4567:89ab:cdef:ABCD:EF01:2345:6789::"); 687 errors += ut_ipv6_pass("2001:0db8:85a3:0000:0000:8a2e:0370:7334", 688 addr_20010db885a3000000008a2e03707334); 689 errors += ut_ipv6_pass("2001:db8:85a3:0:0:8a2e:370:7334", 690 addr_20010db885a3000000008a2e03707334); 691 errors += ut_ipv6_pass("2001:db8:85a3::8a2e:370:7334", 692 addr_20010db885a3000000008a2e03707334); 693 errors += ut_ipv6_pass("ff02::1", 694 addr_ff020000000000000000000000000001); 695 errors += ut_ipv6_pass("::ffff:c000:0280", 696 addr_00000000000000000000ffffc0000280); 697 errors += ut_ipv6_fail(":0:0:0:0:0:0:1"); 698 errors += ut_ipv6_fail(":0:0::0:0:1"); 699 errors += ut_ipv6_fail("0:0:0:0:0:0:0:"); 700 errors += ut_ipv6_fail("0:0:0::0:0:"); 701 errors += ut_ipv6_fail("0:0::0:0::0:0"); 702 errors += ut_ipv6_fail("xyz::zyx"); 703 errors += ut_ipv6_pass(WHITESPACE "1::1" WHITESPACE, 704 addr_00010000000000000000000000000001); 705 errors += ut_ipv6_fail("1\0::1"); 706 errors += ut_ipv6_fail("1::1 ,"); 707 errors += ut_ipv6_fail("abcd"); 708 709 return errors; 710 } 711 712 uint32_t qdf_types_unit_test(void) 713 { 714 uint32_t errors = 0; 715 716 errors += qdf_types_ut_bool_parse(); 717 errors += qdf_types_ut_int32_parse(); 718 errors += qdf_types_ut_int64_parse(); 719 errors += qdf_types_ut_uint32_parse(); 720 errors += qdf_types_ut_uint64_parse(); 721 errors += qdf_types_ut_int_formats_parse(); 722 errors += qdf_types_ut_mac_parse(); 723 errors += qdf_types_ut_ipv4_parse(); 724 errors += qdf_types_ut_ipv6_parse(); 725 errors += qdf_types_ut_uint16_array_parse(); 726 errors += qdf_types_ut_uint32_array_parse(); 727 errors += qdf_types_ut_int32_array_parse(); 728 729 return errors; 730 } 731 732