1 /* 2 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved. 3 */ 4 /* 5 * Copyright (c) 2021 Huawei Device Co., Ltd. 6 * Licensed under the Apache License, Version 2.0 (the "License"); 7 * you may not use this file except in compliance with the License. 8 * You may obtain a copy of the License at 9 * 10 * http://www.apache.org/licenses/LICENSE-2.0 11 * 12 * Unless required by applicable law or agreed to in writing, software 13 * distributed under the License is distributed on an "AS IS" BASIS, 14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 15 * See the License for the specific language governing permissions and 16 * limitations under the License. 17 */ 18 19 #include <strings.h> 20 #include <wctype.h> 21 #include <wchar.h> 22 23 #include "gtest/gtest.h" 24 #include "log.h" 25 #include "utils.h" 26 27 using namespace testing::ext; 28 29 class ActsUtilStringOperApiTest : public testing::Test { 30 public: 31 locale_t g_ausoaLocale; 32 protected: 33 // SetUpTestCase: Testsuit setup, run before 1st testcase SetUpTestCase(void)34 static void SetUpTestCase(void) 35 { 36 } 37 // TearDownTestCase: Testsuit teardown, run after last testcase TearDownTestCase(void)38 static void TearDownTestCase(void) 39 { 40 } 41 // Testcase setup SetUp()42 virtual void SetUp() 43 { 44 g_ausoaLocale = newlocale(LC_ALL_MASK, "", (locale_t)0); 45 } 46 // Testcase teardown TearDown()47 virtual void TearDown() 48 { 49 freelocale(g_ausoaLocale); 50 } 51 }; 52 53 /** 54 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFS_0100 55 * @tc.name test fss api with digit 1 56 * @tc.desc [C- SOFTWARE -0200] 57 */ 58 HWTEST_F(ActsUtilStringOperApiTest, testFss0100, Function | MediumTest | Level1) { 59 int paraValue; 60 int returnVal; 61 62 paraValue = 1; 63 returnVal = ffs(paraValue); 64 LOGD(" ffs returnVal:='%d'\n", returnVal); 65 ASSERT_TRUE(1 == returnVal) << "ErrInfo: ffs returnVal:='" << returnVal << "'"; 66 } 67 68 /** 69 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFS_0200 70 * @tc.name test fss api with digit 0 71 * @tc.desc [C- SOFTWARE -0200] 72 */ 73 HWTEST_F(ActsUtilStringOperApiTest, testFss0200, Function | MediumTest | Level1) { 74 int paraValue; 75 int returnVal; 76 77 paraValue = 0; 78 returnVal = ffs(paraValue); 79 LOGD(" ffs returnVal:='%d'\n", returnVal); 80 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ffs returnVal:='" << returnVal << "'"; 81 } 82 83 /** 84 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFS_0300 85 * @tc.name test fss api with xdigit 86 * @tc.desc [C- SOFTWARE -0200] 87 */ 88 HWTEST_F(ActsUtilStringOperApiTest, testFss0300, Function | MediumTest | Level1) { 89 int paraValue; 90 int returnVal; 91 92 paraValue = 0x8000; 93 returnVal = ffs(paraValue); 94 LOGD(" ffs returnVal:='%d'\n", returnVal); 95 ASSERT_TRUE(16 == returnVal) << "ErrInfo: ffs returnVal:='" << returnVal << "'"; 96 } 97 98 /** 99 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFSL_0400 100 * @tc.name test fssl api with digit 1 101 * @tc.desc [C- SOFTWARE -0200] 102 */ 103 HWTEST_F(ActsUtilStringOperApiTest, testFssl0400, Function | MediumTest | Level1) { 104 long int paraValue; 105 int returnVal; 106 107 paraValue = 1; 108 returnVal = ffsl(paraValue); 109 LOGD(" ffsl returnVal:='%d'\n", returnVal); 110 ASSERT_TRUE(1 == returnVal) << "ErrInfo: ffsl returnVal:='" << returnVal << "'"; 111 } 112 113 /** 114 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFSL_0500 115 * @tc.name test fssl api with digit 0 116 * @tc.desc [C- SOFTWARE -0200] 117 */ 118 HWTEST_F(ActsUtilStringOperApiTest, testFssl0500, Function | MediumTest | Level1) { 119 long int paraValue; 120 int returnVal; 121 122 paraValue = 0; 123 returnVal = ffsl(paraValue); 124 LOGD(" ffsl returnVal:='%d'\n", returnVal); 125 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ffsl returnVal:='" << returnVal << "'"; 126 } 127 128 /** 129 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFSL_0600 130 * @tc.name test fssl api with xdigit 131 * @tc.desc [C- SOFTWARE -0200] 132 */ 133 HWTEST_F(ActsUtilStringOperApiTest, testFssl0600, Function | MediumTest | Level1) { 134 long int paraValue; 135 int returnVal; 136 137 paraValue = 0x8000; 138 returnVal = ffsl(paraValue); 139 LOGD(" ffsl returnVal:='%d'\n", returnVal); 140 ASSERT_TRUE(16 == returnVal) << "ErrInfo: ffsl returnVal:='" << returnVal << "'"; 141 } 142 143 /** 144 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFSLL_0700 145 * @tc.name test fssll api with digit 1 146 * @tc.desc [C- SOFTWARE -0200] 147 */ 148 HWTEST_F(ActsUtilStringOperApiTest, testFssll0700, Function | MediumTest | Level1) { 149 long long int paraValue; 150 int returnVal; 151 152 paraValue = 1; 153 returnVal = ffsll(paraValue); 154 LOGD(" ffsll returnVal:='%d'\n", returnVal); 155 ASSERT_TRUE(1 == returnVal) << "ErrInfo: ffsll returnVal:='" << returnVal << "'"; 156 } 157 158 /** 159 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFSLL_0800 160 * @tc.name test fssll api with digit 0 161 * @tc.desc [C- SOFTWARE -0200] 162 */ 163 HWTEST_F(ActsUtilStringOperApiTest, testFssll0800, Function | MediumTest | Level1) { 164 long long int paraValue; 165 int returnVal; 166 167 paraValue = 0; 168 returnVal = ffsll(paraValue); 169 LOGD(" ffsll returnVal:='%d'\n", returnVal); 170 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ffsll returnVal:='" << returnVal << "'"; 171 } 172 173 /** 174 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_FFSLL_0900 175 * @tc.name test fssll api with xdigit 176 * @tc.desc [C- SOFTWARE -0200] 177 */ 178 HWTEST_F(ActsUtilStringOperApiTest, testFssll0900, Function | MediumTest | Level1) { 179 long long int paraValue; 180 int returnVal; 181 182 paraValue = 0x800000000000; 183 returnVal = ffsll(paraValue); 184 LOGD(" ffsll returnVal:='%d'\n", returnVal); 185 ASSERT_TRUE(48 == returnVal) << "ErrInfo: ffsll returnVal:='" << returnVal << "'"; 186 } 187 188 /** 189 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCWIDTH_1000 190 * @tc.name test wcwidth api with null wide character 191 * @tc.desc [C- SOFTWARE -0200] 192 */ 193 HWTEST_F(ActsUtilStringOperApiTest, testWcwidth1000, Function | MediumTest | Level1) { 194 wchar_t wideChar; 195 int returnVal; 196 197 wideChar = '\0'; 198 returnVal = wcwidth(wideChar); 199 LOGD(" wcwidth returnVal:='%d'\n", returnVal); 200 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcwidth returnVal:='" << returnVal << "'"; 201 } 202 203 /** 204 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCWIDTH_1100 205 * @tc.name test wcwidth api with upper alpha 206 * @tc.desc [C- SOFTWARE -0200] 207 */ 208 HWTEST_F(ActsUtilStringOperApiTest, testWcwidth1100, Function | MediumTest | Level1) { 209 wchar_t wideChar; 210 int returnVal; 211 212 wideChar = 'A'; 213 returnVal = wcwidth(wideChar); 214 LOGD(" wcwidth returnVal:='%d'\n", returnVal); 215 ASSERT_TRUE(1 == returnVal) << "ErrInfo: wcwidth returnVal:='" << returnVal << "'"; 216 } 217 218 /** 219 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCTYPE_1200 220 * @tc.name test wctype api with alnum 221 * @tc.desc [C- SOFTWARE -0200] 222 */ 223 HWTEST_F(ActsUtilStringOperApiTest, testWctype1200, Function | MediumTest | Level1) { 224 const char *paraVal = "alnum"; 225 wctype_t returnVal; 226 227 returnVal = wctype(paraVal); 228 LOGD(" wcwidth returnVal:='%d'\n", returnVal); 229 ASSERT_TRUE(returnVal != 0) << "ErrInfo: wcwidth returnVal:='" << returnVal << "'"; 230 } 231 232 /** 233 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCTYPE_1300 234 * @tc.name test wctype api with alnumalpha 235 * @tc.desc [C- SOFTWARE -0200] 236 */ 237 HWTEST_F(ActsUtilStringOperApiTest, testWctype1300, Function | MediumTest | Level1) { 238 const char *paraVal = "alnumalpha"; 239 wctype_t returnVal; 240 241 returnVal = wctype(paraVal); 242 LOGD(" wcwidth returnVal:='%d'\n", returnVal); 243 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcwidth returnVal:='" << returnVal << "'"; 244 } 245 246 /** 247 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCTYPE_L_1400 248 * @tc.name test wctype_l api with alnum 249 * @tc.desc [C- SOFTWARE -0200] 250 */ 251 HWTEST_F(ActsUtilStringOperApiTest, testWctypeL1400, Function | MediumTest | Level1) { 252 const char *paraVal = "alnum"; 253 wctype_t returnVal; 254 255 returnVal = wctype_l(paraVal, g_ausoaLocale); 256 LOGD(" wctype_l returnVal:='%d'\n", returnVal); 257 ASSERT_TRUE(returnVal != 0) << "ErrInfo: wctype_l returnVal:='" << returnVal << "'"; 258 } 259 260 /** 261 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCTYPE_L_1500 262 * @tc.name test wctype_l api with alnumalpha 263 * @tc.desc [C- SOFTWARE -0200] 264 */ 265 HWTEST_F(ActsUtilStringOperApiTest, testWctypeL1500, Function | MediumTest | Level1) { 266 const char *paraVal = "alnumalpha"; 267 wctype_t returnVal; 268 269 returnVal = wctype_l(paraVal, g_ausoaLocale); 270 LOGD(" wctype_l returnVal:='%d'\n", returnVal); 271 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wctype_l returnVal:='" << returnVal << "'"; 272 } 273 274 /** 275 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_MBLEN_1600 276 * @tc.name test mblen api 277 * @tc.desc [C- SOFTWARE -0200] 278 */ 279 HWTEST_F(ActsUtilStringOperApiTest, testMblen1600, Function | MediumTest | Level1) { 280 const char *paraVal = nullptr; 281 size_t sizeVal; 282 int returnVal; 283 284 paraVal = "a"; 285 sizeVal = 1; 286 returnVal = mblen(paraVal, sizeVal); 287 LOGD(" mblen returnVal:='%d'\n", returnVal); 288 ASSERT_TRUE(1 == returnVal) << "ErrInfo: mblen returnVal:='" << returnVal << "'"; 289 } 290 291 /** 292 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_MBLEN_1700 293 * @tc.name test mbrlen api 294 * @tc.desc [C- SOFTWARE -0200] 295 */ 296 HWTEST_F(ActsUtilStringOperApiTest, testMbrlen1700, Function | MediumTest | Level1) { 297 const char *paraVal = nullptr; 298 size_t sizeVal; 299 mbstate_t *psVal = nullptr; 300 size_t returnVal; 301 302 paraVal = "a"; 303 sizeVal = 1; 304 returnVal = mbrlen(paraVal, sizeVal, psVal); 305 LOGD(" mbrlen returnVal:='%d'\n", returnVal); 306 ASSERT_TRUE(1 == returnVal) << "ErrInfo: mbrlen returnVal:='" << returnVal << "'"; 307 } 308 309 /** 310 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCPCPY_1800 311 * @tc.name test wcpcpy api 312 * @tc.desc [C- SOFTWARE -0200] 313 */ 314 HWTEST_F(ActsUtilStringOperApiTest, testWcpcpy1800, Function | MediumTest | Level1) { 315 wchar_t paraDest[10]; 316 const wchar_t *paraSrc = L"abcde"; 317 wchar_t *returnVal = nullptr; 318 319 returnVal = wcpcpy(paraDest, paraSrc); 320 LOGD(" wcpcpy returnVal:='%x'\n", returnVal); 321 ASSERT_TRUE(0 == wcscmp(paraDest, paraSrc) && L'\0' == *returnVal) 322 << "ErrInfo: wcpcpy returnVal:='" << returnVal << "'"; 323 } 324 325 /** 326 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCPNCPY_1900 327 * @tc.name test wcpncpy api 328 * @tc.desc [C- SOFTWARE -0200] 329 */ 330 HWTEST_F(ActsUtilStringOperApiTest, testWcpncpy1900, Function | MediumTest | Level1) { 331 wchar_t paraDest[10]; 332 const wchar_t *paraSrc = L"abcde"; 333 size_t lenVal; 334 wchar_t *returnVal = nullptr; 335 336 lenVal = wcslen(paraSrc); 337 returnVal = wcpncpy(paraDest, paraSrc, lenVal + 1); 338 LOGD(" wcpncpy returnVal:='%x'\n", returnVal); 339 ASSERT_TRUE(0 == wcsncmp(paraDest, paraSrc, lenVal) && L'\0' == *returnVal) 340 << "ErrInfo: wcpncpy returnVal:='" << returnVal << "'"; 341 } 342 343 /** 344 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCASECMP_2000 345 * @tc.name test wcscasecmp api with para1 is lower case of para2 346 * @tc.desc [C- SOFTWARE -0200] 347 */ 348 HWTEST_F(ActsUtilStringOperApiTest, testWcscasecmp2000, Function | MediumTest | Level1) { 349 const wchar_t *strVal1 = L"abcde"; 350 const wchar_t *strVal2 = L"ABCDE"; 351 int returnVal; 352 353 returnVal = wcscasecmp(strVal1, strVal2); 354 LOGD(" wcscasecmp returnVal:='%d'\n", returnVal); 355 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcscasecmp returnVal:='" << returnVal << "'"; 356 } 357 358 /** 359 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCASECMP_2100 360 * @tc.name test wcscasecmp api with same string 361 * @tc.desc [C- SOFTWARE -0200] 362 */ 363 HWTEST_F(ActsUtilStringOperApiTest, testWcscasecmp2100, Function | MediumTest | Level1) { 364 const wchar_t *strVal1 = L"abcde"; 365 const wchar_t *strVal2 = L"abcde"; 366 int returnVal; 367 368 returnVal = wcscasecmp(strVal1, strVal2); 369 LOGD(" wcscasecmp returnVal:='%d'\n", returnVal); 370 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcscasecmp returnVal:='" << returnVal << "'"; 371 } 372 373 /** 374 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCASECMP_L_2000 375 * @tc.name test wcscasecmp_l api with para1 is lower case of para2 376 * @tc.desc [C- SOFTWARE -0200] 377 */ 378 HWTEST_F(ActsUtilStringOperApiTest, testWcscasecmpL2200, Function | MediumTest | Level1) { 379 const wchar_t *strVal1 = L"abcde"; 380 const wchar_t *strVal2 = L"ABCDE"; 381 int returnVal; 382 383 returnVal = wcscasecmp_l(strVal1, strVal2, g_ausoaLocale); 384 LOGD(" wcscasecmp_l returnVal:='%d'\n", returnVal); 385 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcscasecmp_l returnVal:='" << returnVal << "'"; 386 } 387 388 /** 389 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCASECMP_L_2100 390 * @tc.name test wcscasecmp_l api with same string 391 * @tc.desc [C- SOFTWARE -0200] 392 */ 393 HWTEST_F(ActsUtilStringOperApiTest, testWcscasecmpL2300, Function | MediumTest | Level1) { 394 const wchar_t *strVal1 = L"abcde"; 395 const wchar_t *strVal2 = L"abcde"; 396 int returnVal; 397 398 returnVal = wcscasecmp_l(strVal1, strVal2, g_ausoaLocale); 399 LOGD(" wcscasecmp_l returnVal:='%d'\n", returnVal); 400 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcscasecmp_l returnVal:='" << returnVal << "'"; 401 } 402 403 /** 404 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSNCASECMP_2400 405 * @tc.name test wcsncasecmp api with para1 is lower case of para2 406 * @tc.desc [C- SOFTWARE -0200] 407 */ 408 HWTEST_F(ActsUtilStringOperApiTest, testWcsncasecmp2400, Function | MediumTest | Level1) { 409 const wchar_t *strVal1 = L"abcde"; 410 const wchar_t *strVal2 = L"ABCDE"; 411 size_t lenVal; 412 int returnVal; 413 414 lenVal = 3; 415 returnVal = wcsncasecmp(strVal1, strVal2, lenVal); 416 LOGD(" wcsncasecmp returnVal:='%d'\n", returnVal); 417 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcsncasecmp returnVal:='" << returnVal << "'"; 418 } 419 420 /** 421 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSNCASECMP_2500 422 * @tc.name test wcsncasecmp api with same string 423 * @tc.desc [C- SOFTWARE -0200] 424 */ 425 HWTEST_F(ActsUtilStringOperApiTest, testWcsncasecmp2500, Function | MediumTest | Level1) { 426 const wchar_t *strVal1 = L"abcde"; 427 const wchar_t *strVal2 = L"abcde"; 428 size_t lenVal; 429 int returnVal; 430 431 lenVal = 5; 432 returnVal = wcsncasecmp(strVal1, strVal2, lenVal); 433 LOGD(" wcsncasecmp returnVal:='%d'\n", returnVal); 434 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcsncasecmp returnVal:='" << returnVal << "'"; 435 } 436 437 /** 438 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSNCASECMP_L_2600 439 * @tc.name test wcsncasecmp_l api with para1 is lower case of para2 440 * @tc.desc [C- SOFTWARE -0200] 441 */ 442 HWTEST_F(ActsUtilStringOperApiTest, testWcsncasecmpL2600, Function | MediumTest | Level1) { 443 const wchar_t *strVal1 = L"abcde"; 444 const wchar_t *strVal2 = L"ABCDE"; 445 size_t lenVal; 446 int returnVal; 447 448 lenVal = 3; 449 returnVal = wcsncasecmp_l(strVal1, strVal2, lenVal, g_ausoaLocale); 450 LOGD(" wcsncasecmp_l returnVal:='%d'\n", returnVal); 451 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcsncasecmp_l returnVal:='" << returnVal << "'"; 452 } 453 454 /** 455 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSNCASECMP_L_2700 456 * @tc.name test wcsncasecmp_l api with same string 457 * @tc.desc [C- SOFTWARE -0200] 458 */ 459 HWTEST_F(ActsUtilStringOperApiTest, testWcsncasecmpL2700, Function | MediumTest | Level1) { 460 const wchar_t *strVal1 = L"abcde"; 461 const wchar_t *strVal2 = L"abcde"; 462 size_t lenVal; 463 int returnVal; 464 465 lenVal = 5; 466 returnVal = wcsncasecmp_l(strVal1, strVal2, lenVal, g_ausoaLocale); 467 LOGD(" wcsncasecmp_l returnVal:='%d'\n", returnVal); 468 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcsncasecmp_l returnVal:='" << returnVal << "'"; 469 } 470 471 /** 472 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSNLEN_2800 473 * @tc.name test wcsnlen api 474 * @tc.desc [C- SOFTWARE -0200] 475 */ 476 HWTEST_F(ActsUtilStringOperApiTest, testWcsnlen2800, Function | MediumTest | Level1) { 477 const wchar_t *paraVal = L"abcde"; 478 size_t maxLen; 479 size_t returnVal; 480 481 maxLen = wcslen(paraVal); 482 returnVal = wcsnlen(paraVal, maxLen); 483 LOGD(" wcsnlen returnVal:='%d'\n", returnVal); 484 ASSERT_TRUE(5 == returnVal) << "ErrInfo: wcsnlen returnVal:='" << returnVal << "'"; 485 } 486 487 /** 488 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSWIDTH_2900 489 * @tc.name test wcswidth api 490 * @tc.desc [C- SOFTWARE -0200] 491 */ 492 HWTEST_F(ActsUtilStringOperApiTest, testWcswidth2900, Function | MediumTest | Level1) { 493 const wchar_t *paraVal = L"abcde"; 494 size_t lenVal; 495 int returnVal; 496 497 lenVal = wcslen(paraVal); 498 returnVal = wcswidth(paraVal, lenVal); 499 LOGD(" wcswidth returnVal:='%d'\n", returnVal); 500 ASSERT_TRUE(5 == returnVal) << "ErrInfo: wcswidth returnVal:='" << returnVal << "'"; 501 } 502 503 /** 504 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCAT_3000 505 * @tc.name test wcscat api 506 * @tc.desc [C- SOFTWARE -0200] 507 */ 508 HWTEST_F(ActsUtilStringOperApiTest, testWcscat3000, Function | MediumTest | Level1) { 509 wchar_t paraDest[10]; 510 wchar_t paraSrc[5]; 511 wchar_t *returnVal = nullptr; 512 513 wcscpy(paraDest, L"abc"); 514 wcscpy(paraSrc, L"def"); 515 returnVal = wcscat(paraDest, paraSrc); 516 LOGD(" wcscat returnVal:='%s'\n", returnVal); 517 ASSERT_TRUE(0 == wcscmp(returnVal, L"abcdef")) << "ErrInfo: wcscat returnVal:='" << returnVal << "'"; 518 } 519 520 /** 521 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSNCAT_3100 522 * @tc.name test wcsncat api 523 * @tc.desc [C- SOFTWARE -0200] 524 */ 525 HWTEST_F(ActsUtilStringOperApiTest, testWcsncat3100, Function | MediumTest | Level1) { 526 wchar_t paraDest[10]; 527 wchar_t paraSrc[5]; 528 wchar_t *returnVal = nullptr; 529 530 wcsncpy(paraDest, L"abc", wcslen(L"abc") + 1); 531 wcsncpy(paraSrc, L"def", wcslen(L"def") + 1); 532 returnVal = wcsncat(paraDest, paraSrc, wcslen(L"def")); 533 LOGD(" wcscat returnVal:='%x'\n", returnVal); 534 ASSERT_TRUE(0 == wcscmp(returnVal, L"abcdef")) << "ErrInfo: wcscat returnVal:='" << returnVal << "'"; 535 } 536 537 /** 538 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCHR_3200 539 * @tc.name test wcschr api with wc in wcs 540 * @tc.desc [C- SOFTWARE -0200] 541 */ 542 HWTEST_F(ActsUtilStringOperApiTest, testWcschr3200, Function | MediumTest | Level1) { 543 const wchar_t *paraWcs; 544 wchar_t paraWc; 545 wchar_t *returnVal; 546 547 paraWcs = L"abcdefa"; 548 paraWc = 'a'; 549 returnVal = wcschr((wchar_t *)paraWcs, paraWc); 550 LOGD(" wcschr returnVal:='%x'\n", returnVal); 551 ASSERT_TRUE(paraWcs == returnVal) << "ErrInfo: wcschr *returnVal:='" << *returnVal << "'"; 552 } 553 554 /** 555 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCHR_3300 556 * @tc.name test wcschr api with wc not in wcs 557 * @tc.desc [C- SOFTWARE -0200] 558 */ 559 HWTEST_F(ActsUtilStringOperApiTest, testWcschr3300, Function | MediumTest | Level1) { 560 const wchar_t *paraWcs; 561 wchar_t paraWc; 562 wchar_t *returnVal; 563 564 paraWcs = L"abcdef"; 565 paraWc = 'g'; 566 returnVal = wcschr((wchar_t *)paraWcs, paraWc); 567 LOGD(" wcschr returnVal:='%x'\n", returnVal); 568 ASSERT_TRUE(nullptr == returnVal) << "ErrInfo: wcschr returnVal:='" << returnVal << "'"; 569 } 570 571 /** 572 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSRCHR_3400 573 * @tc.name test wcsrchr api with wc in wcs 574 * @tc.desc [C- SOFTWARE -0200] 575 */ 576 HWTEST_F(ActsUtilStringOperApiTest, testWcsrchr3400, Function | MediumTest | Level1) { 577 const wchar_t *paraWcs; 578 wchar_t paraWc; 579 wchar_t *returnVal; 580 581 paraWcs = L"abcdefa"; 582 paraWc = 'a'; 583 returnVal = wcsrchr((wchar_t *)paraWcs, paraWc); 584 LOGD(" wcsrchr returnVal:='%x %x %x'\n", paraWcs, returnVal, (paraWcs + wcslen(L"abcdef"))); 585 ASSERT_TRUE((paraWcs + wcslen(L"abcdef")) == returnVal) << "ErrInfo: wcsrchr *returnVal:='" << *returnVal << "'"; 586 } 587 588 /** 589 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCHR_3500 590 * @tc.name test wcsrchr api with wc not in wcs 591 * @tc.desc [C- SOFTWARE -0200] 592 */ 593 HWTEST_F(ActsUtilStringOperApiTest, testWcsrchr3500, Function | MediumTest | Level1) { 594 const wchar_t *paraWcs; 595 wchar_t paraWc; 596 wchar_t *returnVal; 597 598 paraWcs = L"abcdef"; 599 paraWc = 'g'; 600 returnVal = wcsrchr((wchar_t *)paraWcs, paraWc); 601 LOGD(" wcsrchr returnVal:='%x'\n", returnVal); 602 ASSERT_TRUE(nullptr == returnVal) << "ErrInfo: wcsrchr returnVal:='" << returnVal << "'"; 603 } 604 605 /** 606 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSDUP_3600 607 * @tc.name test wcsdup api 608 * @tc.desc [C- SOFTWARE -0200] 609 */ 610 HWTEST_F(ActsUtilStringOperApiTest, testWcsdup3600, Function | MediumTest | Level1) { 611 const wchar_t *paraWcs; 612 wchar_t *returnVal; 613 614 paraWcs = L"abcdef"; 615 returnVal = wcsdup(paraWcs); 616 LOGD(" wcsdup returnVal:='%x'\n", returnVal); 617 ASSERT_TRUE(0 == wcscmp(returnVal, paraWcs)) << "ErrInfo: wcsdup returnVal:='" << returnVal << "'"; 618 free(returnVal); 619 } 620 621 /** 622 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCOLL_3700 623 * @tc.name test wcscoll api with para1 is equal to para2 624 * @tc.desc [C- SOFTWARE -0200] 625 */ 626 HWTEST_F(ActsUtilStringOperApiTest, testWcscoll3700, Function | MediumTest | Level1) { 627 const wchar_t *paraWcs1; 628 const wchar_t *paraWcs2; 629 int returnVal; 630 631 paraWcs1 = L"abcdef"; 632 paraWcs2 = L"abcdef"; 633 returnVal = wcscoll(paraWcs1, paraWcs2); 634 LOGD(" wcscoll returnVal:='%d'\n", returnVal); 635 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcscoll returnVal:='" << returnVal << "'"; 636 } 637 638 /** 639 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCOLL_3800 640 * @tc.name test wcscoll api with para1 is greater than para2 641 * @tc.desc [C- SOFTWARE -0200] 642 */ 643 HWTEST_F(ActsUtilStringOperApiTest, testWcscoll3800, Function | MediumTest | Level1) { 644 const wchar_t *paraWcs1; 645 const wchar_t *paraWcs2; 646 int returnVal; 647 648 paraWcs1 = L"abcdefg"; 649 paraWcs2 = L"abcdef"; 650 returnVal = wcscoll(paraWcs1, paraWcs2); 651 LOGD(" wcscoll returnVal:='%d'\n", returnVal); 652 ASSERT_TRUE(returnVal > 0) << "ErrInfo: wcscoll returnVal:='" << returnVal << "'"; 653 } 654 655 /** 656 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCOLL_3900 657 * @tc.name test wcscoll api with para1 is less than para2 658 * @tc.desc [C- SOFTWARE -0200] 659 */ 660 HWTEST_F(ActsUtilStringOperApiTest, testWcscoll3900, Function | MediumTest | Level1) { 661 const wchar_t *paraWcs1; 662 const wchar_t *paraWcs2; 663 int returnVal; 664 665 paraWcs1 = L"abcde"; 666 paraWcs2 = L"abcdef"; 667 returnVal = wcscoll(paraWcs1, paraWcs2); 668 LOGD(" wcscoll returnVal:='%d'\n", returnVal); 669 ASSERT_TRUE(returnVal < 0) << "ErrInfo: wcscoll returnVal:='" << returnVal << "'"; 670 } 671 672 /** 673 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCOLL_L_4000 674 * @tc.name test wcscoll_l api with para1 is equal to para2 675 * @tc.desc [C- SOFTWARE -0200] 676 */ 677 HWTEST_F(ActsUtilStringOperApiTest, testWcscollL4000, Function | MediumTest | Level1) { 678 const wchar_t *paraWcs1; 679 const wchar_t *paraWcs2; 680 int returnVal; 681 682 paraWcs1 = L"abcdef"; 683 paraWcs2 = L"abcdef"; 684 returnVal = wcscoll_l(paraWcs1, paraWcs2, g_ausoaLocale); 685 LOGD(" wcscoll_l returnVal:='%d'\n", returnVal); 686 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcscoll_l returnVal:='" << returnVal << "'"; 687 } 688 689 /** 690 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCOLL_L_4100 691 * @tc.name test wcscoll_l api with para1 is greater than para2 692 * @tc.desc [C- SOFTWARE -0200] 693 */ 694 HWTEST_F(ActsUtilStringOperApiTest, testWcscollL4100, Function | MediumTest | Level1) { 695 const wchar_t *paraWcs1; 696 const wchar_t *paraWcs2; 697 int returnVal; 698 699 paraWcs1 = L"abcdefg"; 700 paraWcs2 = L"abcdef"; 701 returnVal = wcscoll_l(paraWcs1, paraWcs2, g_ausoaLocale); 702 LOGD(" wcscoll_l returnVal:='%d'\n", returnVal); 703 ASSERT_TRUE(returnVal > 0) << "ErrInfo: wcscoll_l returnVal:='" << returnVal << "'"; 704 } 705 706 /** 707 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCOLL_L_4200 708 * @tc.name test wcscoll_l api with para1 is less than para2 709 * @tc.desc [C- SOFTWARE -0200] 710 */ 711 HWTEST_F(ActsUtilStringOperApiTest, testWcscollL4200, Function | MediumTest | Level1) { 712 const wchar_t *paraWcs1; 713 const wchar_t *paraWcs2; 714 int returnVal; 715 716 paraWcs1 = L"abcde"; 717 paraWcs2 = L"abcdef"; 718 returnVal = wcscoll_l(paraWcs1, paraWcs2, g_ausoaLocale); 719 LOGD(" wcscoll_l returnVal:='%d'\n", returnVal); 720 ASSERT_TRUE(returnVal < 0) << "ErrInfo: wcscoll_l returnVal:='" << returnVal << "'"; 721 } 722 723 /** 724 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCSPN_4300 725 * @tc.name test wcscspn api with para2 is included in para1 726 * @tc.desc [C- SOFTWARE -0200] 727 */ 728 HWTEST_F(ActsUtilStringOperApiTest, testWcscspn4300, Function | MediumTest | Level1) { 729 const wchar_t *paraWcs; 730 const wchar_t *paraRjct; 731 size_t returnVal; 732 733 paraWcs = L"abcdef"; 734 paraRjct = L"def"; 735 returnVal = wcscspn(paraWcs, paraRjct); 736 LOGD(" wcscspn returnVal:='%d'\n", returnVal); 737 ASSERT_TRUE(3 == returnVal) << "ErrInfo: wcscspn returnVal:='" << returnVal << "'"; 738 } 739 740 /** 741 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSCSPN_4400 742 * @tc.name test wcscspn api with para2 is not included in para1 743 * @tc.desc [C- SOFTWARE -0200] 744 */ 745 HWTEST_F(ActsUtilStringOperApiTest, testWcscspn4400, Function | MediumTest | Level1) { 746 const wchar_t *paraWcs; 747 const wchar_t *paraRjct; 748 size_t returnVal; 749 750 paraWcs = L"abcdef"; 751 paraRjct = L"ghi"; 752 returnVal = wcscspn(paraWcs, paraRjct); 753 LOGD(" wcscspn returnVal:='%d'\n", returnVal); 754 ASSERT_TRUE(6 == returnVal) << "ErrInfo: wcscspn returnVal:='" << returnVal << "'"; 755 } 756 757 /** 758 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSSPN_4500 759 * @tc.name test wcsspn api with para2 is included in para1 760 * @tc.desc [C- SOFTWARE -0200] 761 */ 762 HWTEST_F(ActsUtilStringOperApiTest, testWcsspn4500, Function | MediumTest | Level1) { 763 const wchar_t *paraWcs; 764 const wchar_t *paraAcpt; 765 size_t returnVal; 766 767 paraWcs = L"abcdef"; 768 paraAcpt = L"def"; 769 returnVal = wcsspn(paraWcs, paraAcpt); 770 LOGD(" wcsspn returnVal:='%d'\n", returnVal); 771 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcsspn returnVal:='" << returnVal << "'"; 772 } 773 774 /** 775 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSSPN_4600 776 * @tc.name test wcscspn api with para2 is not included in para1 777 * @tc.desc [C- SOFTWARE -0200] 778 */ 779 HWTEST_F(ActsUtilStringOperApiTest, testWcsspn4600, Function | MediumTest | Level1) { 780 const wchar_t *paraWcs; 781 const wchar_t *paraAcpt; 782 size_t returnVal; 783 784 paraWcs = L"abcdef"; 785 paraAcpt = L"ghi"; 786 returnVal = wcsspn(paraWcs, paraAcpt); 787 LOGD(" wcsspn returnVal:='%d'\n", returnVal); 788 ASSERT_TRUE(0 == returnVal) << "ErrInfo: wcsspn returnVal:='" << returnVal << "'"; 789 } 790 791 /** 792 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSPBRK_4700 793 * @tc.name test wcspbrk api with para2 is included in para1 794 * @tc.desc [C- SOFTWARE -0200] 795 */ 796 HWTEST_F(ActsUtilStringOperApiTest, testWcspbrk4700, Function | MediumTest | Level1) { 797 const wchar_t *paraWcs; 798 const wchar_t *paraAcpt; 799 wchar_t *returnVal; 800 801 paraWcs = L"abcdef"; 802 paraAcpt = L"def"; 803 returnVal = wcspbrk((wchar_t *)paraWcs, paraAcpt); 804 LOGD(" wcspbrk returnVal:='%x'\n", returnVal); 805 ASSERT_TRUE((paraWcs + wcslen(L"abc")) == returnVal) << "ErrInfo: wcspbrk returnVal:='" << returnVal << "'"; 806 } 807 808 /** 809 * @tc.number SUB_KERNEL_UTIL_STRINGOPER_WCSPBRK_4800 810 * @tc.name test wcspbrk api with para2 is not included in para1 811 * @tc.desc [C- SOFTWARE -0200] 812 */ 813 HWTEST_F(ActsUtilStringOperApiTest, testWcspbrk4800, Function | MediumTest | Level1) { 814 const wchar_t *paraWcs; 815 const wchar_t *paraAcpt; 816 wchar_t *returnVal; 817 818 paraWcs = L"abcdef"; 819 paraAcpt = L"ghi"; 820 returnVal = wcspbrk((wchar_t *)paraWcs, paraAcpt); 821 LOGD(" wcspbrk returnVal:='%x'\n", returnVal); 822 ASSERT_TRUE(nullptr == returnVal) << "ErrInfo: wcspbrk returnVal:='" << returnVal << "'"; 823 } 824