1 /* 2 * Copyright (c) 2021 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include <ctype.h> 17 #include <math.h> 18 #include <stropts.h> 19 20 #include "gtest/gtest.h" 21 #include "log.h" 22 #include "utils.h" 23 24 using namespace testing::ext; 25 26 class ActsUtilCheckApiTest : public testing::Test { 27 public: 28 locale_t g_aucaLocale; 29 protected: 30 // SetUpTestCase: Testsuit setup, run before 1st testcase SetUpTestCase(void)31 static void SetUpTestCase(void) 32 { 33 } 34 // TearDownTestCase: Testsuit teardown, run after last testcase TearDownTestCase(void)35 static void TearDownTestCase(void) 36 { 37 } 38 // Testcase setup SetUp()39 virtual void SetUp() 40 { 41 g_aucaLocale = newlocale(LC_ALL_MASK, "", (locale_t)0); 42 } 43 // Testcase teardown TearDown()44 virtual void TearDown() 45 { 46 freelocale(g_aucaLocale); 47 } 48 }; 49 50 /** 51 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_0100 52 * @tc.name test isalnum api with num 53 * @tc.desc [C- SOFTWARE -0200] 54 */ 55 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0100, Function | MediumTest | Level1) { 56 int paraVal; 57 int returnVal; 58 59 paraVal = '2'; 60 returnVal = isalnum(paraVal); 61 LOGD(" isalnum returnVal:='%d'\n", returnVal); 62 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum returnVal:='" << returnVal << "'"; 63 } 64 65 /** 66 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_0200 67 * @tc.name test isalnum api with lower alpha 68 * @tc.desc [C- SOFTWARE -0200] 69 */ 70 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0200, Function | MediumTest | Level1) { 71 int paraVal; 72 int returnVal; 73 74 paraVal = 'z'; 75 returnVal = isalnum(paraVal); 76 LOGD(" isalnum returnVal:='%d'\n", returnVal); 77 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum returnVal:='" << returnVal << "'"; 78 } 79 80 /** 81 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_0300 82 * @tc.name test isalnum api with upper alpha 83 * @tc.desc [C- SOFTWARE -0200] 84 */ 85 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0300, Function | MediumTest | Level1) { 86 int paraVal; 87 int returnVal; 88 89 paraVal = 'Z'; 90 returnVal = isalnum(paraVal); 91 LOGD(" isalnum returnVal:='%d'\n", returnVal); 92 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum returnVal:='" << returnVal << "'"; 93 } 94 95 /** 96 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_0400 97 * @tc.name test isalnum api with space 98 * @tc.desc [C- SOFTWARE -0200] 99 */ 100 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0400, Function | MediumTest | Level1) { 101 int paraVal; 102 int returnVal; 103 104 paraVal = ' '; 105 returnVal = isalnum(paraVal); 106 LOGD(" isalnum returnVal:='%d'\n", returnVal); 107 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum returnVal:='" << returnVal << "'"; 108 } 109 110 /** 111 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_0500 112 * @tc.name test isalnum api with LF 113 * @tc.desc [C- SOFTWARE -0200] 114 */ 115 HWTEST_F(ActsUtilCheckApiTest, testIsalnum0500, Function | MediumTest | Level1) { 116 int paraVal; 117 int returnVal; 118 119 paraVal = '\n'; 120 returnVal = isalnum(paraVal); 121 LOGD(" isalnum returnVal:='%d'\n", returnVal); 122 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum returnVal:='" << returnVal << "'"; 123 } 124 125 /** 126 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0600 127 * @tc.name test isalnum_l api with num 128 * @tc.desc [C- SOFTWARE -0200] 129 */ 130 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0600, Function | MediumTest | Level1) { 131 int paraVal; 132 int returnVal; 133 134 paraVal = '2'; 135 returnVal = isalnum_l(paraVal, g_aucaLocale); 136 LOGD(" isalnum_l returnVal:='%d'\n", returnVal); 137 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'"; 138 } 139 140 /** 141 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0700 142 * @tc.name test isalnum_l api with lower alpha 143 * @tc.desc [C- SOFTWARE -0200] 144 */ 145 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0700, Function | MediumTest | Level1) { 146 int paraVal; 147 int returnVal; 148 149 paraVal = 'z'; 150 returnVal = isalnum_l(paraVal, g_aucaLocale); 151 LOGD(" isalnum_l returnVal:='%d'\n", returnVal); 152 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'"; 153 } 154 155 /** 156 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0800 157 * @tc.name test isalnum_l api with upper alpha 158 * @tc.desc [C- SOFTWARE -0200] 159 */ 160 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0800, Function | MediumTest | Level1) { 161 int paraVal; 162 int returnVal; 163 164 paraVal = 'Z'; 165 returnVal = isalnum_l(paraVal, g_aucaLocale); 166 LOGD(" isalnum_l returnVal:='%d'\n", returnVal); 167 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'"; 168 } 169 170 /** 171 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_L_0900 172 * @tc.name test isalnum_l api with space 173 * @tc.desc [C- SOFTWARE -0200] 174 */ 175 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL0900, Function | MediumTest | Level1) { 176 int paraVal; 177 int returnVal; 178 179 paraVal = ' '; 180 returnVal = isalnum_l(paraVal, g_aucaLocale); 181 LOGD(" isalnum_l returnVal:='%d'\n", returnVal); 182 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'"; 183 } 184 185 /** 186 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALNUM_L_1000 187 * @tc.name test isalnum_l api with LF 188 * @tc.desc [C- SOFTWARE -0200] 189 */ 190 HWTEST_F(ActsUtilCheckApiTest, testIsalnumL1000, Function | MediumTest | Level1) { 191 int paraVal; 192 int returnVal; 193 194 paraVal = '\n'; 195 returnVal = isalnum_l(paraVal, g_aucaLocale); 196 LOGD(" isalnum_l returnVal:='%d'\n", returnVal); 197 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalnum_l returnVal:='" << returnVal << "'"; 198 } 199 200 /** 201 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_1100 202 * @tc.name test isalpha api with lower alpha 203 * @tc.desc [C- SOFTWARE -0200] 204 */ 205 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1100, Function | MediumTest | Level1) { 206 int paraVal; 207 int returnVal; 208 209 paraVal = 'z'; 210 returnVal = isalpha(paraVal); 211 LOGD(" isalpha returnVal:='%d'\n", returnVal); 212 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha returnVal:='" << returnVal << "'"; 213 } 214 215 /** 216 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_1200 217 * @tc.name test isalpha api with upper alpha 218 * @tc.desc [C- SOFTWARE -0200] 219 */ 220 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1200, Function | MediumTest | Level1) { 221 int paraVal; 222 int returnVal; 223 224 paraVal = 'Z'; 225 returnVal = isalpha(paraVal); 226 LOGD(" isalpha returnVal:='%d'\n", returnVal); 227 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha returnVal:='" << returnVal << "'"; 228 } 229 230 /** 231 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_1300 232 * @tc.name test isalpha api with space 233 * @tc.desc [C- SOFTWARE -0200] 234 */ 235 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1300, Function | MediumTest | Level1) { 236 int paraVal; 237 int returnVal; 238 239 paraVal = ' '; 240 returnVal = isalpha(paraVal); 241 LOGD(" isalpha returnVal:='%d'\n", returnVal); 242 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha returnVal:='" << returnVal << "'"; 243 } 244 245 /** 246 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_1400 247 * @tc.name test isalpha api with LF 248 * @tc.desc [C- SOFTWARE -0200] 249 */ 250 HWTEST_F(ActsUtilCheckApiTest, testIsalpha1400, Function | MediumTest | Level1) { 251 int paraVal; 252 int returnVal; 253 254 paraVal = '\n'; 255 returnVal = isalpha(paraVal); 256 LOGD(" isalpha returnVal:='%d'\n", returnVal); 257 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha returnVal:='" << returnVal << "'"; 258 } 259 260 /** 261 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1500 262 * @tc.name test isalpha_l api with lower alpha 263 * @tc.desc [C- SOFTWARE -0200] 264 */ 265 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1500, Function | MediumTest | Level1) { 266 int paraVal; 267 int returnVal; 268 269 paraVal = 'z'; 270 returnVal = isalpha_l(paraVal, g_aucaLocale); 271 LOGD(" isalpha_l returnVal:='%d'\n", returnVal); 272 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'"; 273 } 274 275 /** 276 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1600 277 * @tc.name test isalpha_l api with upper alpha 278 * @tc.desc [C- SOFTWARE -0200] 279 */ 280 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1600, Function | MediumTest | Level1) { 281 int paraVal; 282 int returnVal; 283 284 paraVal = 'Z'; 285 returnVal = isalpha_l(paraVal, g_aucaLocale); 286 LOGD(" isalpha_l returnVal:='%d'\n", returnVal); 287 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'"; 288 } 289 290 /** 291 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1700 292 * @tc.name test isalpha_l api with space 293 * @tc.desc [C- SOFTWARE -0200] 294 */ 295 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1700, Function | MediumTest | Level1) { 296 int paraVal; 297 int returnVal; 298 299 paraVal = ' '; 300 returnVal = isalpha_l(paraVal, g_aucaLocale); 301 LOGD(" isalpha_l returnVal:='%d'\n", returnVal); 302 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'"; 303 } 304 305 /** 306 * @tc.number SUB_KERNEL_UTIL_CHECK_ISALPHA_L_1800 307 * @tc.name test isalpha_l api with LF 308 * @tc.desc [C- SOFTWARE -0200] 309 */ 310 HWTEST_F(ActsUtilCheckApiTest, testIsalphaL1800, Function | MediumTest | Level1) { 311 int paraVal; 312 int returnVal; 313 314 paraVal = '\n'; 315 returnVal = isalpha_l(paraVal, g_aucaLocale); 316 LOGD(" isalpha_l returnVal:='%d'\n", returnVal); 317 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isalpha_l returnVal:='" << returnVal << "'"; 318 } 319 320 /** 321 * @tc.number SUB_KERNEL_UTIL_CHECK_ISASCII_1900 322 * @tc.name test isascii api with lower alpha 323 * @tc.desc [C- SOFTWARE -0200] 324 */ 325 HWTEST_F(ActsUtilCheckApiTest, testIsascii1900, Function | MediumTest | Level1) { 326 int paraVal; 327 int returnVal; 328 329 paraVal = 'z'; 330 returnVal = isascii(paraVal); 331 LOGD(" isascii returnVal:='%d'\n", returnVal); 332 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isascii returnVal:='" << returnVal << "'"; 333 } 334 335 /** 336 * @tc.number SUB_KERNEL_UTIL_CHECK_ISASCII_2000 337 * @tc.name test isascii api with upper alpha 338 * @tc.desc [C- SOFTWARE -0200] 339 */ 340 HWTEST_F(ActsUtilCheckApiTest, testIsascii2000, Function | MediumTest | Level1) { 341 int paraVal; 342 int returnVal; 343 344 paraVal = 'Z'; 345 returnVal = isascii(paraVal); 346 LOGD(" isascii returnVal:='%d'\n", returnVal); 347 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isascii returnVal:='" << returnVal << "'"; 348 } 349 350 /** 351 * @tc.number SUB_KERNEL_UTIL_CHECK_ISASCII_2100 352 * @tc.name test isascii api with special symbol 353 * @tc.desc [C- SOFTWARE -0200] 354 */ 355 HWTEST_F(ActsUtilCheckApiTest, testIsascii2100, Function | MediumTest | Level1) { 356 int paraVal; 357 int returnVal; 358 359 paraVal = '~'; 360 returnVal = isascii(paraVal); 361 LOGD(" isascii returnVal:='%d'\n", returnVal); 362 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isascii returnVal:='" << returnVal << "'"; 363 } 364 365 /** 366 * @tc.number SUB_KERNEL_UTIL_CHECK_ISASCII_2200 367 * @tc.name test isascii api with digit 368 * @tc.desc [C- SOFTWARE -0200] 369 */ 370 HWTEST_F(ActsUtilCheckApiTest, testIsascii2200, Function | MediumTest | Level1) { 371 int paraVal; 372 int returnVal; 373 374 paraVal = 128; 375 returnVal = isascii(paraVal); 376 LOGD(" isascii returnVal:='%d'\n", returnVal); 377 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isascii returnVal:='" << returnVal << "'"; 378 } 379 380 // /** 381 // * @tc.number SUB_KERNEL_UTIL_CHECK_ISASTREAM_2300 382 // * @tc.name test isastream api with digit 383 // * @tc.desc [C- SOFTWARE -0200] 384 // */ 385 // HWTEST_F(ActsUtilCheckApiTest, testIsastream2300, Function | MediumTest | Level1) { 386 // int paraVal; 387 // int returnVal; 388 389 // paraVal = 128; 390 // ASSERT_TRUE(-1 == returnVal) << "ErrInfo: isastream returnVal:='" << returnVal << "'"; 391 // } 392 393 /** 394 * @tc.number SUB_KERNEL_UTIL_CHECK_ISATTY_2400 395 * @tc.name test isatty api with digit 396 * @tc.desc [C- SOFTWARE -0200] 397 */ 398 HWTEST_F(ActsUtilCheckApiTest, testIsatty2400, Function | MediumTest | Level1) { 399 int paraVal; 400 int returnVal; 401 402 paraVal = 128; 403 returnVal = isatty(paraVal); 404 LOGD(" isatty returnVal:='%d'\n", returnVal); 405 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isatty returnVal:='" << returnVal << "'"; 406 } 407 408 /** 409 * @tc.number SUB_KERNEL_UTIL_CHECK_ISBLANK_2500 410 * @tc.name test isblank api with space 411 * @tc.desc [C- SOFTWARE -0200] 412 */ 413 HWTEST_F(ActsUtilCheckApiTest, testIsblank2500, Function | MediumTest | Level1) { 414 int paraVal; 415 int returnVal; 416 417 paraVal = ' '; 418 returnVal = isblank(paraVal); 419 LOGD(" isblank returnVal:='%d'\n", returnVal); 420 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isblank returnVal:='" << returnVal << "'"; 421 } 422 423 /** 424 * @tc.number SUB_KERNEL_UTIL_CHECK_ISBLANK_2600 425 * @tc.name test isblank api with upper alpha 426 * @tc.desc [C- SOFTWARE -0200] 427 */ 428 HWTEST_F(ActsUtilCheckApiTest, testIsblank2600, Function | MediumTest | Level1) { 429 int paraVal; 430 int returnVal; 431 432 paraVal = 'A'; 433 returnVal = isblank(paraVal); 434 LOGD(" isblank returnVal:='%d'\n", returnVal); 435 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isblank returnVal:='" << returnVal << "'"; 436 } 437 438 /** 439 * @tc.number SUB_KERNEL_UTIL_CHECK_ISBLANK_L_2700 440 * @tc.name test isblank_l api with space 441 * @tc.desc [C- SOFTWARE -0200] 442 */ 443 HWTEST_F(ActsUtilCheckApiTest, testIsblankL2700, Function | MediumTest | Level1) { 444 int paraVal; 445 int returnVal; 446 447 paraVal = ' '; 448 returnVal = isblank_l(paraVal, g_aucaLocale); 449 LOGD(" isblank_l returnVal:='%d'\n", returnVal); 450 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isblank_l returnVal:='" << returnVal << "'"; 451 } 452 453 /** 454 * @tc.number SUB_KERNEL_UTIL_CHECK_ISBLANK_L_2800 455 * @tc.name test isblank_l api with upper alpha 456 * @tc.desc [C- SOFTWARE -0200] 457 */ 458 HWTEST_F(ActsUtilCheckApiTest, testIsblankL2800, Function | MediumTest | Level1) { 459 int paraVal; 460 int returnVal; 461 462 paraVal = 'A'; 463 returnVal = isblank_l(paraVal, g_aucaLocale); 464 LOGD(" isblank_l returnVal:='%d'\n", returnVal); 465 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isblank_l returnVal:='" << returnVal << "'"; 466 } 467 468 /** 469 * @tc.number SUB_KERNEL_UTIL_CHECK_ISCNTRL_2900 470 * @tc.name test iscntrl api with LF 471 * @tc.desc [C- SOFTWARE -0200] 472 */ 473 HWTEST_F(ActsUtilCheckApiTest, testIscntrl2900, Function | MediumTest | Level1) { 474 int paraVal; 475 int returnVal; 476 477 paraVal = '\n'; 478 returnVal = iscntrl(paraVal); 479 LOGD(" iscntrl returnVal:='%d'\n", returnVal); 480 ASSERT_TRUE(returnVal != 0) << "ErrInfo: iscntrl returnVal:='" << returnVal << "'"; 481 } 482 483 /** 484 * @tc.number SUB_KERNEL_UTIL_CHECK_ISCNTRL_3000 485 * @tc.name test iscntrl api with upper alpha 486 * @tc.desc [C- SOFTWARE -0200] 487 */ 488 HWTEST_F(ActsUtilCheckApiTest, testIscntrl3000, Function | MediumTest | Level1) { 489 int paraVal; 490 int returnVal; 491 492 paraVal = 'A'; 493 returnVal = iscntrl(paraVal); 494 LOGD(" iscntrl returnVal:='%d'\n", returnVal); 495 ASSERT_TRUE(0 == returnVal) << "ErrInfo: iscntrl returnVal:='" << returnVal << "'"; 496 } 497 498 /** 499 * @tc.number SUB_KERNEL_UTIL_CHECK_ISCNTRL_L_3100 500 * @tc.name test iscntrl_l api with LF 501 * @tc.desc [C- SOFTWARE -0200] 502 */ 503 HWTEST_F(ActsUtilCheckApiTest, testIscntrlL3100, Function | MediumTest | Level1) { 504 int paraVal; 505 int returnVal; 506 507 paraVal = '\n'; 508 returnVal = iscntrl_l(paraVal, g_aucaLocale); 509 LOGD(" iscntrl_l returnVal:='%d'\n", returnVal); 510 ASSERT_TRUE(returnVal != 0) << "ErrInfo: iscntrl_l returnVal:='" << returnVal << "'"; 511 } 512 513 /** 514 * @tc.number SUB_KERNEL_UTIL_CHECK_ISCNTRL_L_3200 515 * @tc.name test iscntrl_l api with upper alpha 516 * @tc.desc [C- SOFTWARE -0200] 517 */ 518 HWTEST_F(ActsUtilCheckApiTest, testIscntrlL3200, Function | MediumTest | Level1) { 519 int paraVal; 520 int returnVal; 521 522 paraVal = 'A'; 523 returnVal = iscntrl_l(paraVal, g_aucaLocale); 524 LOGD(" iscntrl_l returnVal:='%d'\n", returnVal); 525 ASSERT_TRUE(0 == returnVal) << "ErrInfo: iscntrl_l returnVal:='" << returnVal << "'"; 526 } 527 528 /** 529 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_3300 530 * @tc.name test isdigit api with digit 531 * @tc.desc [C- SOFTWARE -0200] 532 */ 533 HWTEST_F(ActsUtilCheckApiTest, testIsdigit3300, Function | MediumTest | Level1) { 534 int paraVal; 535 int returnVal; 536 537 paraVal = '3'; 538 returnVal = isdigit(paraVal); 539 LOGD(" isdigit returnVal:='%d'\n", returnVal); 540 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isdigit returnVal:='" << returnVal << "'"; 541 } 542 543 /** 544 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_3400 545 * @tc.name test isdigit api with lower alpha 546 * @tc.desc [C- SOFTWARE -0200] 547 */ 548 HWTEST_F(ActsUtilCheckApiTest, testIsdigitl3400, Function | MediumTest | Level1) { 549 int paraVal; 550 int returnVal; 551 552 paraVal = 'a'; 553 returnVal = isdigit(paraVal); 554 LOGD(" isdigit returnVal:='%d'\n", returnVal); 555 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'"; 556 } 557 558 /** 559 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_3500 560 * @tc.name test isdigit api with LF 561 * @tc.desc [C- SOFTWARE -0200] 562 */ 563 HWTEST_F(ActsUtilCheckApiTest, testIsdigitl3500, Function | MediumTest | Level1) { 564 int paraVal; 565 int returnVal; 566 567 paraVal = '\n'; 568 returnVal = isdigit(paraVal); 569 LOGD(" isdigit returnVal:='%d'\n", returnVal); 570 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'"; 571 } 572 573 /** 574 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_3600 575 * @tc.name test isdigit api with space 576 * @tc.desc [C- SOFTWARE -0200] 577 */ 578 HWTEST_F(ActsUtilCheckApiTest, testIsdigit3600, Function | MediumTest | Level1) { 579 int paraVal; 580 int returnVal; 581 582 paraVal = ' '; 583 returnVal = isdigit(paraVal); 584 LOGD(" isdigit returnVal:='%d'\n", returnVal); 585 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit returnVal:='" << returnVal << "'"; 586 } 587 588 /** 589 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3700 590 * @tc.name test isdigit_l api with digit 591 * @tc.desc [C- SOFTWARE -0200] 592 */ 593 HWTEST_F(ActsUtilCheckApiTest, testIsdigitL3700, Function | MediumTest | Level1) { 594 int paraVal; 595 int returnVal; 596 597 paraVal = '3'; 598 returnVal = isdigit_l(paraVal, g_aucaLocale); 599 LOGD(" isdigit_l returnVal:='%d'\n", returnVal); 600 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'"; 601 } 602 603 /** 604 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3800 605 * @tc.name test isdigit_l api with lower alpha 606 * @tc.desc [C- SOFTWARE -0200] 607 */ 608 HWTEST_F(ActsUtilCheckApiTest, testIsdigitlL3800, Function | MediumTest | Level1) { 609 int paraVal; 610 int returnVal; 611 612 paraVal = 'a'; 613 returnVal = isdigit_l(paraVal, g_aucaLocale); 614 LOGD(" isdigit_l returnVal:='%d'\n", returnVal); 615 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'"; 616 } 617 618 /** 619 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_3900 620 * @tc.name test isdigit_l api with LF 621 * @tc.desc [C- SOFTWARE -0200] 622 */ 623 HWTEST_F(ActsUtilCheckApiTest, testIsdigitlL3900, Function | MediumTest | Level1) { 624 int paraVal; 625 int returnVal; 626 627 paraVal = '\n'; 628 returnVal = isdigit_l(paraVal, g_aucaLocale); 629 LOGD(" isdigit_l returnVal:='%d'\n", returnVal); 630 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'"; 631 } 632 633 /** 634 * @tc.number SUB_KERNEL_UTIL_CHECK_ISDIGIT_L_4000 635 * @tc.name test isdigit_l api with space 636 * @tc.desc [C- SOFTWARE -0200] 637 */ 638 HWTEST_F(ActsUtilCheckApiTest, testIsdigitL4000, Function | MediumTest | Level1) { 639 int paraVal; 640 int returnVal; 641 642 paraVal = ' '; 643 returnVal = isdigit_l(paraVal, g_aucaLocale); 644 LOGD(" isdigit_l returnVal:='%d'\n", returnVal); 645 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isdigit_l returnVal:='" << returnVal << "'"; 646 } 647 648 /** 649 * @tc.number SUB_KERNEL_UTIL_CHECK_ISFINITE_4100 650 * @tc.name test isfinite api with space 651 * @tc.desc [C- SOFTWARE -0200] 652 */ 653 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4100, Function | MediumTest | Level1) { 654 double paraVal; 655 int returnVal; 656 657 paraVal = ' '; 658 returnVal = isfinite(paraVal); 659 LOGD(" isfinite returnVal:='%d'\n", returnVal); 660 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'"; 661 } 662 663 /** 664 * @tc.number SUB_KERNEL_UTIL_CHECK_ISFINITE_4200 665 * @tc.name test isfinite api with decimal double 666 * @tc.desc [C- SOFTWARE -0200] 667 */ 668 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4200, Function | MediumTest | Level1) { 669 double paraVal; 670 int returnVal; 671 672 paraVal = 3.1415926; 673 returnVal = isfinite(paraVal); 674 LOGD(" isfinite returnVal:='%d'\n", returnVal); 675 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'"; 676 } 677 678 /** 679 * @tc.number SUB_KERNEL_UTIL_CHECK_ISFINITE_4300 680 * @tc.name test isfinite api with exponent double 681 * @tc.desc [C- SOFTWARE -0200] 682 */ 683 HWTEST_F(ActsUtilCheckApiTest, testIsfinite4300, Function | MediumTest | Level1) { 684 double paraVal; 685 int returnVal; 686 687 paraVal = 1.26e3; 688 returnVal = isfinite(paraVal); 689 LOGD(" isfinite returnVal:='%d'\n", returnVal); 690 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isfinite returnVal:='" << returnVal << "'"; 691 } 692 693 /** 694 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_4400 695 * @tc.name test isgraph api with upper alpha 696 * @tc.desc [C- SOFTWARE -0200] 697 */ 698 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4400, Function | MediumTest | Level1) { 699 double paraVal; 700 int returnVal; 701 702 paraVal = 'A'; 703 returnVal = isgraph(paraVal); 704 LOGD(" isgraph returnVal:='%d'\n", returnVal); 705 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 706 } 707 708 /** 709 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_4500 710 * @tc.name test isgraph api with lower alpha 711 * @tc.desc [C- SOFTWARE -0200] 712 */ 713 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4500, Function | MediumTest | Level1) { 714 double paraVal; 715 int returnVal; 716 717 paraVal = 'z'; 718 returnVal = isgraph(paraVal); 719 LOGD(" isgraph returnVal:='%d'\n", returnVal); 720 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 721 } 722 723 /** 724 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_4600 725 * @tc.name test isgraph api with LF 726 * @tc.desc [C- SOFTWARE -0200] 727 */ 728 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4600, Function | MediumTest | Level1) { 729 double paraVal; 730 int returnVal; 731 732 paraVal = '\n'; 733 returnVal = isgraph(paraVal); 734 LOGD(" isgraph returnVal:='%d'\n", returnVal); 735 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 736 } 737 738 /** 739 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_4700 740 * @tc.name test isgraph api with space 741 * @tc.desc [C- SOFTWARE -0200] 742 */ 743 HWTEST_F(ActsUtilCheckApiTest, testIsgraph4700, Function | MediumTest | Level1) { 744 double paraVal; 745 int returnVal; 746 747 paraVal = ' '; 748 returnVal = isgraph(paraVal); 749 LOGD(" isgraph returnVal:='%d'\n", returnVal); 750 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 751 } 752 753 /** 754 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_4800 755 * @tc.name test isgraph_l api with upper alpha 756 * @tc.desc [C- SOFTWARE -0200] 757 */ 758 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL4800, Function | MediumTest | Level1) { 759 double paraVal; 760 int returnVal; 761 762 paraVal = 'A'; 763 returnVal = isgraph_l(paraVal, g_aucaLocale); 764 LOGD(" isgraph returnVal:='%d'\n", returnVal); 765 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 766 } 767 768 /** 769 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_4900 770 * @tc.name test isgraph_l api with lower alpha 771 * @tc.desc [C- SOFTWARE -0200] 772 */ 773 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL4900, Function | MediumTest | Level1) { 774 double paraVal; 775 int returnVal; 776 777 paraVal = 'z'; 778 returnVal = isgraph_l(paraVal, g_aucaLocale); 779 LOGD(" isgraph returnVal:='%d'\n", returnVal); 780 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 781 } 782 783 /** 784 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_5000 785 * @tc.name test isgraph_l api with LF 786 * @tc.desc [C- SOFTWARE -0200] 787 */ 788 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL5000, Function | MediumTest | Level1) { 789 double paraVal; 790 int returnVal; 791 792 paraVal = '\n'; 793 returnVal = isgraph_l(paraVal, g_aucaLocale); 794 LOGD(" isgraph returnVal:='%d'\n", returnVal); 795 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 796 } 797 798 /** 799 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGRAPH_L_5100 800 * @tc.name test isgraph_l api with space 801 * @tc.desc [C- SOFTWARE -0200] 802 */ 803 HWTEST_F(ActsUtilCheckApiTest, testIsgraphL5100, Function | MediumTest | Level1) { 804 double paraVal; 805 int returnVal; 806 807 paraVal = ' '; 808 returnVal = isgraph_l(paraVal, g_aucaLocale); 809 LOGD(" isgraph returnVal:='%d'\n", returnVal); 810 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgraph returnVal:='" << returnVal << "'"; 811 } 812 813 /** 814 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGREATER_5200 815 * @tc.name test isgreater api para1 is less than para2 816 * @tc.desc [C- SOFTWARE -0200] 817 */ 818 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5200, Function | MediumTest | Level1) { 819 double paraVal1; 820 double paraVal2; 821 int returnVal; 822 823 paraVal1 = 1.1; 824 paraVal2 = 2.1; 825 returnVal = isgreater(paraVal1, paraVal2); 826 LOGD(" isgreater returnVal:='%d'\n", returnVal); 827 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreater returnVal:='" << returnVal << "'"; 828 } 829 830 /** 831 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGREATER_5300 832 * @tc.name test isgreater api para1 is greater than para2 833 * @tc.desc [C- SOFTWARE -0200] 834 */ 835 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5300, Function | MediumTest | Level1) { 836 double paraVal1; 837 double paraVal2; 838 int returnVal; 839 840 paraVal1 = 2.1; 841 paraVal2 = 1.1; 842 returnVal = isgreater(paraVal1, paraVal2); 843 LOGD(" isgreater returnVal:='%d'\n", returnVal); 844 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreater returnVal:='" << returnVal << "'"; 845 } 846 847 /** 848 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGREATER_5400 849 * @tc.name test isgreater api para1 is equal to para2 850 * @tc.desc [C- SOFTWARE -0200] 851 */ 852 HWTEST_F(ActsUtilCheckApiTest, testIsgreater5400, Function | MediumTest | Level1) { 853 double paraVal1; 854 double paraVal2; 855 int returnVal; 856 857 paraVal1 = 2.1; 858 paraVal2 = 2.1; 859 returnVal = isgreater(paraVal1, paraVal2); 860 LOGD(" isgreater returnVal:='%d'\n", returnVal); 861 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreater returnVal:='" << returnVal << "'"; 862 } 863 864 /** 865 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5500 866 * @tc.name test isgreaterequal api para1 is less than para2 867 * @tc.desc [C- SOFTWARE -0200] 868 */ 869 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5500, Function | MediumTest | Level1) { 870 double paraVal1; 871 double paraVal2; 872 int returnVal; 873 874 paraVal1 = 1.1; 875 paraVal2 = 2.1; 876 returnVal = isgreaterequal(paraVal1, paraVal2); 877 LOGD(" isgreaterequal returnVal:='%d'\n", returnVal); 878 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'"; 879 } 880 881 /** 882 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5600 883 * @tc.name test isgreaterequal api para1 is greater than para2 884 * @tc.desc [C- SOFTWARE -0200] 885 */ 886 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5600, Function | MediumTest | Level1) { 887 double paraVal1; 888 double paraVal2; 889 int returnVal; 890 891 paraVal1 = 2.1; 892 paraVal2 = 1.1; 893 returnVal = isgreaterequal(paraVal1, paraVal2); 894 LOGD(" isgreaterequal returnVal:='%d'\n", returnVal); 895 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'"; 896 } 897 898 /** 899 * @tc.number SUB_KERNEL_UTIL_CHECK_ISGREATEREQUAL_5700 900 * @tc.name test isgreaterequal api para1 is equal to para2 901 * @tc.desc [C- SOFTWARE -0200] 902 */ 903 HWTEST_F(ActsUtilCheckApiTest, testIsgreaterequal5700, Function | MediumTest | Level1) { 904 double paraVal1; 905 double paraVal2; 906 int returnVal; 907 908 paraVal1 = 2.1; 909 paraVal2 = 2.1; 910 returnVal = isgreaterequal(paraVal1, paraVal2); 911 LOGD(" isgreaterequal returnVal:='%d'\n", returnVal); 912 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isgreaterequal returnVal:='" << returnVal << "'"; 913 } 914 915 /** 916 * @tc.number SUB_KERNEL_UTIL_CHECK_ISINF_5800 917 * @tc.name test isinf api with INFINITY 918 * @tc.desc [C- SOFTWARE -0200] 919 */ 920 HWTEST_F(ActsUtilCheckApiTest, testIsinf5800, Function | MediumTest | Level1) { 921 double paraVal; 922 int returnVal; 923 924 paraVal = INFINITY; 925 returnVal = isinf(paraVal); 926 LOGD(" isinf returnVal:='%d'\n", returnVal); 927 ASSERT_TRUE(1 == returnVal) << "ErrInfo: isinf returnVal:='" << returnVal << "'"; 928 } 929 930 /** 931 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_5900 932 * @tc.name test islessequal api para1 is less than para2 933 * @tc.desc [C- SOFTWARE -0200] 934 */ 935 HWTEST_F(ActsUtilCheckApiTest, testIslessequal5900, Function | MediumTest | Level1) { 936 double paraVal1; 937 double paraVal2; 938 int returnVal; 939 940 paraVal1 = 1.1; 941 paraVal2 = 2.1; 942 returnVal = islessequal(paraVal1, paraVal2); 943 LOGD(" islessequal returnVal:='%d'\n", returnVal); 944 ASSERT_TRUE(0 != returnVal) << "ErrInfo: islessequal returnVal:='" << returnVal << "'"; 945 } 946 947 /** 948 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_6000 949 * @tc.name test islessequal api para1 is greater than para2 950 * @tc.desc [C- SOFTWARE -0200] 951 */ 952 HWTEST_F(ActsUtilCheckApiTest, testIslessequal6000, Function | MediumTest | Level1) { 953 double paraVal1; 954 double paraVal2; 955 int returnVal; 956 957 paraVal1 = 2.1; 958 paraVal2 = 1.1; 959 returnVal = islessequal(paraVal1, paraVal2); 960 LOGD(" islessequal returnVal:='%d'\n", returnVal); 961 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islessequal returnVal:='" << returnVal << "'"; 962 } 963 964 /** 965 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLESSEQUAL_6100 966 * @tc.name test islessequal api para1 is equal to para2 967 * @tc.desc [C- SOFTWARE -0200] 968 */ 969 HWTEST_F(ActsUtilCheckApiTest, testIslessequal6100, Function | MediumTest | Level1) { 970 double paraVal1; 971 double paraVal2; 972 int returnVal; 973 974 paraVal1 = 2.1; 975 paraVal2 = 2.1; 976 returnVal = islessequal(paraVal1, paraVal2); 977 LOGD(" islessequal returnVal:='%d'\n", returnVal); 978 ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessequal returnVal:='" << returnVal << "'"; 979 } 980 981 /** 982 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6200 983 * @tc.name test islessgreater api para1 is equal to para2 984 * @tc.desc [C- SOFTWARE -0200] 985 */ 986 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6200, Function | MediumTest | Level1) { 987 double paraVal1; 988 double paraVal2; 989 int returnVal; 990 991 paraVal1 = 2.1; 992 paraVal2 = 2.1; 993 returnVal = islessgreater(paraVal1, paraVal2); 994 LOGD(" islessgreater returnVal:='%d'\n", returnVal); 995 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'"; 996 } 997 998 /** 999 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6300 1000 * @tc.name test islessgreater api para1 is less than para2 1001 * @tc.desc [C- SOFTWARE -0200] 1002 */ 1003 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6300, Function | MediumTest | Level1) { 1004 double paraVal1; 1005 double paraVal2; 1006 int returnVal; 1007 1008 paraVal1 = 1.1; 1009 paraVal2 = 2.1; 1010 returnVal = islessgreater(paraVal1, paraVal2); 1011 LOGD(" islessgreater returnVal:='%d'\n", returnVal); 1012 ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'"; 1013 } 1014 1015 /** 1016 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLESSGREATER_6400 1017 * @tc.name test islessgreater api para1 is greater than para2 1018 * @tc.desc [C- SOFTWARE -0200] 1019 */ 1020 HWTEST_F(ActsUtilCheckApiTest, testIslessgreater6400, Function | MediumTest | Level1) { 1021 double paraVal1; 1022 double paraVal2; 1023 int returnVal; 1024 1025 paraVal1 = 3.1; 1026 paraVal2 = 2.1; 1027 returnVal = islessgreater(paraVal1, paraVal2); 1028 LOGD(" islessgreater returnVal:='%d'\n", returnVal); 1029 ASSERT_TRUE(returnVal != 0) << "ErrInfo: islessgreater returnVal:='" << returnVal << "'"; 1030 } 1031 1032 /** 1033 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_6500 1034 * @tc.name test islower api with upper alpha 1035 * @tc.desc [C- SOFTWARE -0200] 1036 */ 1037 HWTEST_F(ActsUtilCheckApiTest, testIslower6500, Function | MediumTest | Level1) { 1038 char paraChar; 1039 int returnVal; 1040 1041 paraChar = 'A'; 1042 returnVal = islower(paraChar); 1043 LOGD(" islower c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1044 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1045 } 1046 1047 /** 1048 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_6600 1049 * @tc.name test islower api with lower alpha 1050 * @tc.desc [C- SOFTWARE -0200] 1051 */ 1052 HWTEST_F(ActsUtilCheckApiTest, testIslower6600, Function | MediumTest | Level1) { 1053 char paraChar; 1054 int returnVal; 1055 1056 paraChar = 'a'; 1057 returnVal = islower(paraChar); 1058 LOGD(" islower c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1059 ASSERT_TRUE(returnVal != 0) << "ErrInfo: islower c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1060 } 1061 1062 /** 1063 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_6700 1064 * @tc.name test islower api with digit 1065 * @tc.desc [C- SOFTWARE -0200] 1066 */ 1067 HWTEST_F(ActsUtilCheckApiTest, testIslower6700, Function | MediumTest | Level1) { 1068 char paraChar; 1069 int returnVal; 1070 1071 paraChar = '5'; 1072 returnVal = islower(paraChar); 1073 LOGD(" islower c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1074 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1075 } 1076 1077 /** 1078 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_6800 1079 * @tc.name test islower api with space 1080 * @tc.desc [C- SOFTWARE -0200] 1081 */ 1082 HWTEST_F(ActsUtilCheckApiTest, testIslower6800, Function | MediumTest | Level1) { 1083 char paraChar; 1084 int returnVal; 1085 1086 paraChar = ' '; 1087 returnVal = islower(paraChar); 1088 LOGD(" islower c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1089 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1090 } 1091 1092 /** 1093 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_L_6900 1094 * @tc.name test islower_l api with upper alpha 1095 * @tc.desc [C- SOFTWARE -0200] 1096 */ 1097 HWTEST_F(ActsUtilCheckApiTest, testIslowerL6900, Function | MediumTest | Level1) { 1098 char paraChar; 1099 int returnVal; 1100 1101 paraChar = 'A'; 1102 returnVal = islower_l(paraChar, g_aucaLocale); 1103 LOGD(" islower_l c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1104 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1105 } 1106 1107 /** 1108 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7000 1109 * @tc.name test islower_l api with lower alpha 1110 * @tc.desc [C- SOFTWARE -0200] 1111 */ 1112 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7000, Function | MediumTest | Level1) { 1113 char paraChar; 1114 int returnVal; 1115 1116 paraChar = 'a'; 1117 returnVal = islower_l(paraChar, g_aucaLocale); 1118 LOGD(" islower_l c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1119 ASSERT_TRUE(returnVal != 0) << "ErrInfo: islower_l c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1120 } 1121 1122 /** 1123 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7100 1124 * @tc.name test islower_l api with digit 1125 * @tc.desc [C- SOFTWARE -0200] 1126 */ 1127 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7100, Function | MediumTest | Level1) { 1128 char paraChar; 1129 int returnVal; 1130 1131 paraChar = '5'; 1132 returnVal = islower_l(paraChar, g_aucaLocale); 1133 LOGD(" islower_l c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1134 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1135 } 1136 1137 /** 1138 * @tc.number SUB_KERNEL_UTIL_CHECK_ISLOWER_L_7200 1139 * @tc.name test islower_l api with space 1140 * @tc.desc [C- SOFTWARE -0200] 1141 */ 1142 HWTEST_F(ActsUtilCheckApiTest, testIslowerL7200, Function | MediumTest | Level1) { 1143 char paraChar; 1144 int returnVal; 1145 1146 paraChar = ' '; 1147 returnVal = islower_l(paraChar, g_aucaLocale); 1148 LOGD(" islower_l c:='%c', returnVal:='%c'\n", paraChar, returnVal); 1149 ASSERT_TRUE(0 == returnVal) << "ErrInfo: islower_l c:='" << paraChar << "', returnVal:='" << returnVal << "'"; 1150 } 1151 1152 /** 1153 * @tc.number SUB_KERNEL_UTIL_CHECK_ISNAN_7300 1154 * @tc.name test isnan api with NAN 1155 * @tc.desc [C- SOFTWARE -0200] 1156 */ 1157 HWTEST_F(ActsUtilCheckApiTest, testIsnan7300, Function | MediumTest | Level1) { 1158 double paraVal; 1159 int returnVal; 1160 1161 paraVal = NAN; 1162 returnVal = isnan(paraVal); 1163 LOGD(" isnan returnVal:='%d'\n", returnVal); 1164 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnan returnVal:='" << returnVal << "'"; 1165 } 1166 1167 /** 1168 * @tc.number SUB_KERNEL_UTIL_CHECK_ISNORMAL_7400 1169 * @tc.name test isnormal api with FP_NORMAL 1170 * @tc.desc [C- SOFTWARE -0200] 1171 */ 1172 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7400, Function | MediumTest | Level1) { 1173 double paraVal; 1174 int returnVal; 1175 1176 paraVal = FP_NORMAL; 1177 returnVal = isnormal(paraVal); 1178 LOGD(" isnormal returnVal:='%d'\n", returnVal); 1179 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnormal returnVal:='" << returnVal << "'"; 1180 } 1181 1182 /** 1183 * @tc.number SUB_KERNEL_UTIL_CHECK_ISNORMAL_7500 1184 * @tc.name test isnormal api with NAN 1185 * @tc.desc [C- SOFTWARE -0200] 1186 */ 1187 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7500, Function | MediumTest | Level1) { 1188 double paraVal; 1189 int returnVal; 1190 1191 paraVal = NAN; 1192 returnVal = isnormal(paraVal); 1193 LOGD(" isnormal returnVal:='%d'\n", returnVal); 1194 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isnormal returnVal:='" << returnVal << "'"; 1195 } 1196 1197 /** 1198 * @tc.number SUB_KERNEL_UTIL_CHECK_ISNORMAL_7600 1199 * @tc.name test isnormal api with double 1200 * @tc.desc [C- SOFTWARE -0200] 1201 */ 1202 HWTEST_F(ActsUtilCheckApiTest, testIsnormal7600, Function | MediumTest | Level1) { 1203 double paraVal; 1204 int returnVal; 1205 1206 paraVal = 2.1; 1207 returnVal = isnormal(paraVal); 1208 LOGD(" isnormal returnVal:='%d'\n", returnVal); 1209 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isnormal returnVal:='" << returnVal << "'"; 1210 } 1211 1212 /** 1213 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPRINT_7700 1214 * @tc.name test isprint api with lower alpha 1215 * @tc.desc [C- SOFTWARE -0200] 1216 */ 1217 HWTEST_F(ActsUtilCheckApiTest, testIsprint7700, Function | MediumTest | Level1) { 1218 char paraVal; 1219 int returnVal; 1220 1221 paraVal = 'a'; 1222 returnVal = isprint(paraVal); 1223 LOGD(" isprint returnVal:='%d'\n", returnVal); 1224 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint returnVal:='" << returnVal << "'"; 1225 } 1226 1227 /** 1228 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPRINT_7800 1229 * @tc.name test isprint api with space 1230 * @tc.desc [C- SOFTWARE -0200] 1231 */ 1232 HWTEST_F(ActsUtilCheckApiTest, testIsprint7800, Function | MediumTest | Level1) { 1233 char paraVal; 1234 int returnVal; 1235 1236 paraVal = ' '; 1237 returnVal = isprint(paraVal); 1238 LOGD(" isprint returnVal:='%d'\n", returnVal); 1239 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint returnVal:='" << returnVal << "'"; 1240 } 1241 1242 /** 1243 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPRINT_7900 1244 * @tc.name test isprint api with LF 1245 * @tc.desc [C- SOFTWARE -0200] 1246 */ 1247 HWTEST_F(ActsUtilCheckApiTest, testIsprint7900, Function | MediumTest | Level1) { 1248 char paraVal; 1249 int returnVal; 1250 1251 paraVal = '\n'; 1252 returnVal = isprint(paraVal); 1253 LOGD(" isprint returnVal:='%d'\n", returnVal); 1254 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isprint returnVal:='" << returnVal << "'"; 1255 } 1256 1257 /** 1258 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8000 1259 * @tc.name test isprint_l api with lower alpha 1260 * @tc.desc [C- SOFTWARE -0200] 1261 */ 1262 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8000, Function | MediumTest | Level1) { 1263 char paraVal; 1264 int returnVal; 1265 1266 paraVal = 'a'; 1267 returnVal = isprint_l(paraVal, g_aucaLocale); 1268 LOGD(" isprint_l returnVal:='%d'\n", returnVal); 1269 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint_l returnVal:='" << returnVal << "'"; 1270 } 1271 1272 /** 1273 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8100 1274 * @tc.name test isprint_l api with space 1275 * @tc.desc [C- SOFTWARE -0200] 1276 */ 1277 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8100, Function | MediumTest | Level1) { 1278 char paraVal; 1279 int returnVal; 1280 1281 paraVal = ' '; 1282 returnVal = isprint_l(paraVal, g_aucaLocale); 1283 LOGD(" isprint_l returnVal:='%d'\n", returnVal); 1284 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isprint_l returnVal:='" << returnVal << "'"; 1285 } 1286 1287 /** 1288 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPRINT_L_8200 1289 * @tc.name test isprint_l api with LF 1290 * @tc.desc [C- SOFTWARE -0200] 1291 */ 1292 HWTEST_F(ActsUtilCheckApiTest, testIsprintL8200, Function | MediumTest | Level1) { 1293 char paraVal; 1294 int returnVal; 1295 1296 paraVal = '\n'; 1297 returnVal = isprint_l(paraVal, g_aucaLocale); 1298 LOGD(" isprint_l returnVal:='%d'\n", returnVal); 1299 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isprint_l returnVal:='" << returnVal << "'"; 1300 } 1301 1302 /** 1303 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPUNCT_8300 1304 * @tc.name test ispunct api with space 1305 * @tc.desc [C- SOFTWARE -0200] 1306 */ 1307 HWTEST_F(ActsUtilCheckApiTest, testIspunct8300, Function | MediumTest | Level1) { 1308 char paraVal; 1309 int returnVal; 1310 1311 paraVal = ' '; 1312 returnVal = ispunct(paraVal); 1313 LOGD(" ispunct returnVal:='%d'\n", returnVal); 1314 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct returnVal:='" << returnVal << "'"; 1315 } 1316 1317 /** 1318 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPUNCT_8400 1319 * @tc.name test ispunct api with upper alpha 1320 * @tc.desc [C- SOFTWARE -0200] 1321 */ 1322 HWTEST_F(ActsUtilCheckApiTest, testIspunct8400, Function | MediumTest | Level1) { 1323 char paraVal; 1324 int returnVal; 1325 1326 paraVal = 'A'; 1327 returnVal = ispunct(paraVal); 1328 LOGD(" ispunct returnVal:='%d'\n", returnVal); 1329 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct returnVal:='" << returnVal << "'"; 1330 } 1331 1332 /** 1333 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPUNCT_8500 1334 * @tc.name test ispunct api with LF 1335 * @tc.desc [C- SOFTWARE -0200] 1336 */ 1337 HWTEST_F(ActsUtilCheckApiTest, testIspunct8500, Function | MediumTest | Level1) { 1338 char paraVal; 1339 int returnVal; 1340 1341 paraVal = '\n'; 1342 returnVal = ispunct(paraVal); 1343 LOGD(" ispunct returnVal:='%d'\n", returnVal); 1344 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct returnVal:='" << returnVal << "'"; 1345 } 1346 1347 /** 1348 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8600 1349 * @tc.name test ispunct_l api with space 1350 * @tc.desc [C- SOFTWARE -0200] 1351 */ 1352 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8600, Function | MediumTest | Level1) { 1353 char paraVal; 1354 int returnVal; 1355 1356 paraVal = ' '; 1357 returnVal = ispunct_l(paraVal, g_aucaLocale); 1358 LOGD(" ispunct_l returnVal:='%d'\n", returnVal); 1359 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l returnVal:='" << returnVal << "'"; 1360 } 1361 1362 /** 1363 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8700 1364 * @tc.name test ispunct_l api with upper alpha 1365 * @tc.desc [C- SOFTWARE -0200] 1366 */ 1367 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8700, Function | MediumTest | Level1) { 1368 char paraVal; 1369 int returnVal; 1370 1371 paraVal = 'A'; 1372 returnVal = ispunct_l(paraVal, g_aucaLocale); 1373 LOGD(" ispunct_l returnVal:='%d'\n", returnVal); 1374 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l returnVal:='" << returnVal << "'"; 1375 } 1376 1377 /** 1378 * @tc.number SUB_KERNEL_UTIL_CHECK_ISPUNCT_L_8800 1379 * @tc.name test ispunct_l api with LF 1380 * @tc.desc [C- SOFTWARE -0200] 1381 */ 1382 HWTEST_F(ActsUtilCheckApiTest, testIspunctL8800, Function | MediumTest | Level1) { 1383 char paraVal; 1384 int returnVal; 1385 1386 paraVal = '\n'; 1387 returnVal = ispunct_l(paraVal, g_aucaLocale); 1388 LOGD(" ispunct_l returnVal:='%d'\n", returnVal); 1389 ASSERT_TRUE(0 == returnVal) << "ErrInfo: ispunct_l returnVal:='" << returnVal << "'"; 1390 } 1391 1392 /** 1393 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_8900 1394 * @tc.name test isspace api with lower alpha 1395 * @tc.desc [C- SOFTWARE -0200] 1396 */ 1397 HWTEST_F(ActsUtilCheckApiTest, testIsspace8900, Function | MediumTest | Level1) { 1398 char paraVal; 1399 int returnVal; 1400 1401 paraVal = 'a'; 1402 returnVal = isspace(paraVal); 1403 LOGD(" isspace returnVal:='%d'\n", returnVal); 1404 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isspace returnVal:='" << returnVal << "'"; 1405 } 1406 1407 /** 1408 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_9000 1409 * @tc.name test isspace api with space 1410 * @tc.desc [C- SOFTWARE -0200] 1411 */ 1412 HWTEST_F(ActsUtilCheckApiTest, testIsspace9000, Function | MediumTest | Level1) { 1413 char paraVal; 1414 int returnVal; 1415 1416 paraVal = ' '; 1417 returnVal = isspace(paraVal); 1418 LOGD(" isspace returnVal:='%d'\n", returnVal); 1419 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace returnVal:='" << returnVal << "'"; 1420 } 1421 1422 /** 1423 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_9100 1424 * @tc.name test isspace api with LF 1425 * @tc.desc [C- SOFTWARE -0200] 1426 */ 1427 HWTEST_F(ActsUtilCheckApiTest, testIsspace9100, Function | MediumTest | Level1) { 1428 char paraVal; 1429 int returnVal; 1430 1431 paraVal = '\n'; 1432 returnVal = isspace(paraVal); 1433 LOGD(" isspace returnVal:='%d'\n", returnVal); 1434 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace returnVal:='" << returnVal << "'"; 1435 } 1436 1437 /** 1438 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_9200 1439 * @tc.name test isspace api with CR 1440 * @tc.desc [C- SOFTWARE -0200] 1441 */ 1442 HWTEST_F(ActsUtilCheckApiTest, testIsspace9200, Function | MediumTest | Level1) { 1443 char paraVal; 1444 int returnVal; 1445 1446 paraVal = '\r'; 1447 returnVal = isspace(paraVal); 1448 LOGD(" isspace returnVal:='%d'\n", returnVal); 1449 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace returnVal:='" << returnVal << "'"; 1450 } 1451 1452 /** 1453 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_9300 1454 * @tc.name test isspace api with form-feed 1455 * @tc.desc [C- SOFTWARE -0200] 1456 */ 1457 HWTEST_F(ActsUtilCheckApiTest, testIsspace9300, Function | MediumTest | Level1) { 1458 char paraVal; 1459 int returnVal; 1460 1461 paraVal = '\f'; 1462 returnVal = isspace(paraVal); 1463 LOGD(" isspace returnVal:='%d'\n", returnVal); 1464 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace returnVal:='" << returnVal << "'"; 1465 } 1466 1467 /** 1468 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_9400 1469 * @tc.name test isspace api with horizontal tab 1470 * @tc.desc [C- SOFTWARE -0200] 1471 */ 1472 HWTEST_F(ActsUtilCheckApiTest, testIsspace9400, Function | MediumTest | Level1) { 1473 char paraVal; 1474 int returnVal; 1475 1476 paraVal = '\t'; 1477 returnVal = isspace(paraVal); 1478 LOGD(" isspace returnVal:='%d'\n", returnVal); 1479 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace returnVal:='" << returnVal << "'"; 1480 } 1481 1482 /** 1483 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9500 1484 * @tc.name test isspace_l api with lower alpha 1485 * @tc.desc [C- SOFTWARE -0200] 1486 */ 1487 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9500, Function | MediumTest | Level1) { 1488 char paraVal; 1489 int returnVal; 1490 1491 paraVal = 'a'; 1492 returnVal = isspace_l(paraVal, g_aucaLocale); 1493 LOGD(" isspace_l returnVal:='%d'\n", returnVal); 1494 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isspace_l returnVal:='" << returnVal << "'"; 1495 } 1496 1497 /** 1498 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9600 1499 * @tc.name test isspace_l api with space 1500 * @tc.desc [C- SOFTWARE -0200] 1501 */ 1502 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9600, Function | MediumTest | Level1) { 1503 char paraVal; 1504 int returnVal; 1505 1506 paraVal = ' '; 1507 returnVal = isspace_l(paraVal, g_aucaLocale); 1508 LOGD(" isspace_l returnVal:='%d'\n", returnVal); 1509 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l returnVal:='" << returnVal << "'"; 1510 } 1511 1512 /** 1513 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9620 1514 * @tc.name test isspace_l api with LF 1515 * @tc.desc [C- SOFTWARE -0200] 1516 */ 1517 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9620, Function | MediumTest | Level1) { 1518 char paraVal; 1519 int returnVal; 1520 1521 paraVal = '\n'; 1522 returnVal = isspace_l(paraVal, g_aucaLocale); 1523 LOGD(" isspace_l returnVal:='%d'\n", returnVal); 1524 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l returnVal:='" << returnVal << "'"; 1525 } 1526 1527 /** 1528 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9640 1529 * @tc.name test isspace_l api with CR 1530 * @tc.desc [C- SOFTWARE -0200] 1531 */ 1532 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9640, Function | MediumTest | Level1) { 1533 char paraVal; 1534 int returnVal; 1535 1536 paraVal = '\r'; 1537 returnVal = isspace_l(paraVal, g_aucaLocale); 1538 LOGD(" isspace_l returnVal:='%d'\n", returnVal); 1539 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l returnVal:='" << returnVal << "'"; 1540 } 1541 1542 /** 1543 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9660 1544 * @tc.name test isspace_l api with form-feed 1545 * @tc.desc [C- SOFTWARE -0200] 1546 */ 1547 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9660, Function | MediumTest | Level1) { 1548 char paraVal; 1549 int returnVal; 1550 1551 paraVal = '\f'; 1552 returnVal = isspace_l(paraVal, g_aucaLocale); 1553 LOGD(" isspace_l returnVal:='%d'\n", returnVal); 1554 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l returnVal:='" << returnVal << "'"; 1555 } 1556 1557 /** 1558 * @tc.number SUB_KERNEL_UTIL_CHECK_ISSPACE_L_9680 1559 * @tc.name test isspace_l api with horizontal tab 1560 * @tc.desc [C- SOFTWARE -0200] 1561 */ 1562 HWTEST_F(ActsUtilCheckApiTest, testIsspaceL9680, Function | MediumTest | Level1) { 1563 char paraVal; 1564 int returnVal; 1565 1566 paraVal = '\t'; 1567 returnVal = isspace_l(paraVal, g_aucaLocale); 1568 LOGD(" isspace_l returnVal:='%d'\n", returnVal); 1569 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isspace_l returnVal:='" << returnVal << "'"; 1570 } 1571 1572 /** 1573 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUNORDERED_9700 1574 * @tc.name test isunordered api with NAN and 0 1575 * @tc.desc [C- SOFTWARE -0200] 1576 */ 1577 HWTEST_F(ActsUtilCheckApiTest, testIsunordered9700, Function | MediumTest | Level1) { 1578 double paraVal1; 1579 double paraVal2; 1580 int returnVal; 1581 1582 paraVal1 = NAN; 1583 paraVal2 = 0; 1584 returnVal = isunordered(paraVal1, paraVal2); 1585 LOGD(" isunordered returnVal:='%d'\n", returnVal); 1586 ASSERT_TRUE(1 == returnVal) << "ErrInfo: isunordered returnVal:='" << returnVal << "'"; 1587 } 1588 1589 /** 1590 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_9720 1591 * @tc.name test isupper api with upper alpha 1592 * @tc.desc [C- SOFTWARE -0200] 1593 */ 1594 HWTEST_F(ActsUtilCheckApiTest, testIsupper9720, Function | MediumTest | Level1) { 1595 char paraVal; 1596 int returnVal; 1597 1598 paraVal = 'A'; 1599 returnVal = isupper(paraVal); 1600 LOGD(" isupper returnVal:='%d'\n", returnVal); 1601 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isupper returnVal:='" << returnVal << "'"; 1602 } 1603 1604 /** 1605 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_9740 1606 * @tc.name test isupper api with lower alpha 1607 * @tc.desc [C- SOFTWARE -0200] 1608 */ 1609 HWTEST_F(ActsUtilCheckApiTest, testIsupper9740, Function | MediumTest | Level1) { 1610 char paraVal; 1611 int returnVal; 1612 1613 paraVal = 'a'; 1614 returnVal = isupper(paraVal); 1615 LOGD(" isupper returnVal:='%d'\n", returnVal); 1616 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper returnVal:='" << returnVal << "'"; 1617 } 1618 1619 /** 1620 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_9760 1621 * @tc.name test isupper api with digit 1622 * @tc.desc [C- SOFTWARE -0200] 1623 */ 1624 HWTEST_F(ActsUtilCheckApiTest, testIsupper9760, Function | MediumTest | Level1) { 1625 char paraVal; 1626 int returnVal; 1627 1628 paraVal = '5'; 1629 returnVal = isupper(paraVal); 1630 LOGD(" isupper returnVal:='%d'\n", returnVal); 1631 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper returnVal:='" << returnVal << "'"; 1632 } 1633 1634 /** 1635 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_9780 1636 * @tc.name test isupper api with LF 1637 * @tc.desc [C- SOFTWARE -0200] 1638 */ 1639 HWTEST_F(ActsUtilCheckApiTest, testIsupper9780, Function | MediumTest | Level1) { 1640 char paraVal; 1641 int returnVal; 1642 1643 paraVal = '\n'; 1644 returnVal = isupper(paraVal); 1645 LOGD(" isupper returnVal:='%d'\n", returnVal); 1646 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper returnVal:='" << returnVal << "'"; 1647 } 1648 1649 /** 1650 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9800 1651 * @tc.name test isupper_l api with upper alpha 1652 * @tc.desc [C- SOFTWARE -0200] 1653 */ 1654 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9800, Function | MediumTest | Level1) { 1655 char paraVal; 1656 int returnVal; 1657 1658 paraVal = 'A'; 1659 returnVal = isupper_l(paraVal, g_aucaLocale); 1660 LOGD(" isupper_l returnVal:='%d'\n", returnVal); 1661 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isupper_l returnVal:='" << returnVal << "'"; 1662 } 1663 1664 /** 1665 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9820 1666 * @tc.name test isupper_l api with lower alpha 1667 * @tc.desc [C- SOFTWARE -0200] 1668 */ 1669 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9820, Function | MediumTest | Level1) { 1670 char paraVal; 1671 int returnVal; 1672 1673 paraVal = 'a'; 1674 returnVal = isupper_l(paraVal, g_aucaLocale); 1675 LOGD(" isupper_l returnVal:='%d'\n", returnVal); 1676 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l returnVal:='" << returnVal << "'"; 1677 } 1678 1679 /** 1680 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9840 1681 * @tc.name test isupper_l api with digit 1682 * @tc.desc [C- SOFTWARE -0200] 1683 */ 1684 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9840, Function | MediumTest | Level1) { 1685 char paraVal; 1686 int returnVal; 1687 1688 paraVal = '5'; 1689 returnVal = isupper_l(paraVal, g_aucaLocale); 1690 LOGD(" isupper_l returnVal:='%d'\n", returnVal); 1691 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l returnVal:='" << returnVal << "'"; 1692 } 1693 1694 /** 1695 * @tc.number SUB_KERNEL_UTIL_CHECK_ISUPPER_L_9860 1696 * @tc.name test isupper_l api with LF 1697 * @tc.desc [C- SOFTWARE -0200] 1698 */ 1699 HWTEST_F(ActsUtilCheckApiTest, testIsupperL9860, Function | MediumTest | Level1) { 1700 char paraVal; 1701 int returnVal; 1702 1703 paraVal = '\n'; 1704 returnVal = isupper_l(paraVal, g_aucaLocale); 1705 LOGD(" isupper_l returnVal:='%d'\n", returnVal); 1706 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isupper_l returnVal:='" << returnVal << "'"; 1707 } 1708 1709 /** 1710 * @tc.number SUB_KERNEL_UTIL_CHECK_ISXDIGIT_9880 1711 * @tc.name test isxdigit api with xdigit F 1712 * @tc.desc [C- SOFTWARE -0200] 1713 */ 1714 HWTEST_F(ActsUtilCheckApiTest, testIsxdigit9880, Function | MediumTest | Level1) { 1715 char paraVal; 1716 int returnVal; 1717 1718 paraVal = 'F'; 1719 returnVal = isxdigit(paraVal); 1720 LOGD(" isxdigit returnVal:='%d'\n", returnVal); 1721 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isxdigit returnVal:='" << returnVal << "'"; 1722 } 1723 1724 /** 1725 * @tc.number SUB_KERNEL_UTIL_CHECK_ISXDIGIT_9900 1726 * @tc.name test isxdigit api with alpha G 1727 * @tc.desc [C- SOFTWARE -0200] 1728 */ 1729 HWTEST_F(ActsUtilCheckApiTest, testIsxdigit9900, Function | MediumTest | Level1) { 1730 char paraVal; 1731 int returnVal; 1732 1733 paraVal = 'G'; 1734 returnVal = isxdigit(paraVal); 1735 LOGD(" isxdigit returnVal:='%d'\n", returnVal); 1736 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isxdigit returnVal:='" << returnVal << "'"; 1737 } 1738 1739 /** 1740 * @tc.number SUB_KERNEL_UTIL_CHECK_ISXDIGIT_L_9920 1741 * @tc.name test isxdigit_l api with xdigit F 1742 * @tc.desc [C- SOFTWARE -0200] 1743 */ 1744 HWTEST_F(ActsUtilCheckApiTest, testIsxdigitL9920, Function | MediumTest | Level1) { 1745 char paraVal; 1746 int returnVal; 1747 1748 paraVal = 'F'; 1749 returnVal = isxdigit_l(paraVal, g_aucaLocale); 1750 LOGD(" isxdigit_l returnVal:='%d'\n", returnVal); 1751 ASSERT_TRUE(returnVal != 0) << "ErrInfo: isxdigit_l returnVal:='" << returnVal << "'"; 1752 } 1753 1754 /** 1755 * @tc.number SUB_KERNEL_UTIL_CHECK_ISXDIGIT_L_9940 1756 * @tc.name test isxdigit_l api with alpha G 1757 * @tc.desc [C- SOFTWARE -0200] 1758 */ 1759 HWTEST_F(ActsUtilCheckApiTest, testIsxdigitL19940, Function | MediumTest | Level1) { 1760 char paraVal; 1761 int returnVal; 1762 1763 paraVal = 'G'; 1764 returnVal = isxdigit_l(paraVal, g_aucaLocale); 1765 LOGD(" isxdigit_l returnVal:='%d'\n", returnVal); 1766 ASSERT_TRUE(0 == returnVal) << "ErrInfo: isxdigit_l returnVal:='" << returnVal << "'"; 1767 }