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