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 "SignalTest.h" 17#include <unistd.h> 18#include <string.h> 19#include <stdlib.h> 20#include <fcntl.h> 21#include <sys/shm.h> 22#include <sys/types.h> 23#include <sys/stat.h> 24#include "log.h" 25#include "utils.h" 26#include "KernelConstants.h" 27 28using namespace testing::ext; 29 30/** 31 * @tc.number SUB_KERNEL_IPC_SIG_ALL_0100 32 * @tc.name test the default action when receive a signal 33 default action: http://man7.org/linux/man-pages/man7/signal.7.html 34 * @tc.desc [C- SOFTWARE -0200] 35 */ 36HWTEST_P(IpcSignalTest, testAllSigDefaultAction, Function | MediumTest | Level1) 37{ 38 int index = GetParam(); 39 SignalAction a = ALL_SIGNALS[index].action; 40 bool expectStop, coredump; 41 if (a == STOP) { // SIGSTOP should has no effect in liteos 42 expectStop = false; 43 coredump = false; 44 } else if (a == COREDUMP) { 45 expectStop = true; 46 coredump = true; 47 } else if (a == TERMINATE) { 48 expectStop = true; 49 coredump = false; 50 } else { 51 // CONTINUE's default action is ignore, if the process is not Stopped 52 expectStop = false; 53 coredump = false; 54 } 55 LOG("all supported signal DefaultActionTest test %d: %s, expectStop=%d", 56 index, ALL_SIGNALS[index].signame, expectStop); 57 DefaultActionTest(index, expectStop, coredump); 58 Msleep(100); // don't test too fast 59} 60 61/** 62 * @tc.number SUB_KERNEL_IPC_SIG_ALL_0200 63 * @tc.name test all supported signal's send and receive. SIGKILL, SIGSTOP SIGCONT is special, not tested here 64 * @tc.desc [C- SOFTWARE -0200] 65 */ 66HWTEST_P(IpcSignalTest, testAllSigSendAndRecv, Function | MediumTest | Level1) 67{ 68 int index = GetParam(); 69 // SIGKILL/SIGSTOP cannot be caught, blocked, or ignored, can not test here 70 if (index==SIGKILL || index==SIGSTOP || index==SIGCONT) { 71 return; 72 } 73 LOG("all supported signal SendAndRecv test %d: %s", index, ALL_SIGNALS[index].signame); 74 SendAndRecvTest(index); 75 Msleep(100); // don't test too fast 76} 77 78/** 79 * @tc.number SUB_KERNEL_IPC_SIG_ALL_0250 80 * @tc.name test all signal's description string 81 * @tc.desc [C- SOFTWARE -0200] 82 */ 83HWTEST_P(IpcSignalTest, testAllSigDescription, Function | MediumTest | Level3) 84{ 85 int signo = GetParam(); 86 const char* descipt = ALL_SIGNALS[signo].description; 87 LOG("all supported signal's description string test: %d(%s)", signo, ALL_SIGNALS[signo].signame); 88 89 // we use child to do the test here, cause 'restore of stderr' is not work by now. 90 pid_t pid = fork(); 91 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 92 if (pid == 0) { // child 93 // redirect stderr to a file, so we can check the content. 94 char* outfile = WRITABLE_TEST_DIR "stderr.txt"; 95 if (freopen(outfile, "w", stderr) == NULL) { 96 LOG("redirect stderr fail, freopen errno=%d\n", errno); 97 exit(1); 98 } 99 psignal(signo, nullptr); 100 int rt = CheckSigString(outfile, descipt); 101 exit(rt); 102 } else { // parent 103 WaitProcExitedOK(pid); 104 } 105 Msleep(100); // don't test too fast 106} 107INSTANTIATE_TEST_CASE_P(AllSignalTest, IpcSignalTest, testing::Range(1, MAX_SIGNAL)); 108 109/** 110 * @tc.number SUB_KERNEL_IPC_SIG_ALL_0300 111 * @tc.name test SIGKILL can't blocked. SIGSTOP can't be blocked too, but not supported by liteos 112 * @tc.desc [C- SOFTWARE -0200] 113 */ 114HWTEST_F(IpcSignalTest, testBlockSIGKILL, Function | MediumTest | Level2) 115{ 116 pid_t pid = fork(); 117 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 118 if (pid > 0) { // parent 119 LOG("parent in"); 120 Msleep(50); 121 LOGD("parent: before kill"); 122 kill(pid, SIGKILL); 123 Msleep(150); // wait to exit 124 WaitProcKilled(pid, SIGKILL); 125 } else { // child 126 LOG("child in"); 127 sigset_t set; 128 sigemptyset(&set); 129 sigaddset(&set, SIGKILL); 130 int rt = sigprocmask(SIG_BLOCK, &set, nullptr); 131 LOG("sigprocmask rt = %d", rt); 132 KeepRun(100); 133 LOG("child exit 0"); 134 exit(0); 135 } 136} 137 138/** 139 * @tc.number SUB_KERNEL_IPC_SIG_ALL_0400 140 * @tc.name test SIGKILL can't suspended. 141 * @tc.desc [C- SOFTWARE -0200] 142 */ 143HWTEST_F(IpcSignalTest, testSuspendSIGKILL, Function | MediumTest | Level3) 144{ 145 pid_t pid = fork(); 146 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 147 if (pid > 0) { // parent 148 Msleep(20); 149 kill(pid, SIGKILL); 150 Msleep(150); // wait to exit 151 WaitProcKilled(pid, SIGKILL); 152 } else { // child 153 sigset_t set; 154 sigemptyset(&set); 155 sigaddset(&set, SIGKILL); 156 LOG("before sigsuspend"); 157 int rt = sigsuspend(&set); 158 LOG("sigsuspend rt = %d", rt); 159 KeepRun(100); 160 exit(0); 161 } 162} 163 164/** 165 * @tc.number SUB_KERNEL_IPC_SIGNAL_0100 166 * @tc.name test SIGKILL and SIGSTOP's action can not changed by signal 167 * @tc.desc [C- SOFTWARE -0200] 168 */ 169HWTEST_F(IpcSignalTest, testSignalFailSig, Function | MediumTest | Level2) 170{ 171 SignalFailTest(SIGKILL, SignalHandler); 172 SignalFailTest(SIGKILL, SIG_IGN); 173 SignalFailTest(SIGSTOP, SignalHandler); 174 SignalFailTest(SIGSTOP, SIG_IGN); 175 SignalFailTest(31, SignalHandler); 176 SignalFailTest(32, SignalHandler); 177 SignalFailTest(33, SignalHandler); 178} 179 180/** 181 * @tc.number SUB_KERNEL_IPC_SIGNAL_0200 182 * @tc.name test SIG_IGN and SIG_DFL 183 * @tc.desc [C- SOFTWARE -0200] 184 */ 185HWTEST_F(IpcSignalTest, testSignal_DFL_IGN, Function | MediumTest | Level2) 186{ 187 pid_t pid = fork(); 188 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 189 if (pid == 0) { // child 190 int exitCode = 0; 191 LOG("change handler to SIG_IGN"); 192 signal(SIGURG, SIG_IGN); 193 Msleep(40); 194 if (mReceivedSignal != 0) { 195 LOG("Received signal check fail, expected 0, but get %d", mReceivedSignal); 196 exitCode = 1; 197 } 198 199 LOG("change handler to SignalHandler"); 200 signal(SIGURG, SignalHandler); 201 mReceivedSignal = 0; 202 Msleep(50); 203 if (mReceivedSignal != SIGURG) { 204 LOG("Received signal check fail, expected %d, but get %d", SIGURG, mReceivedSignal); 205 exitCode = 1; 206 } 207 208 LOG("change handler to SIG_DFL"); 209 signal(SIGURG, SIG_DFL); 210 mReceivedSignal = 0; 211 Msleep(50); 212 if (mReceivedSignal != 0) { 213 LOG("Received signal check fail, expected 0, but get %d", mReceivedSignal); 214 exitCode = 1; 215 } 216 exit(exitCode); 217 } else { // parent 218 Msleep(20); 219 LOG("------ Send SIGURG 1"); 220 kill(pid, SIGURG); 221 Msleep(50); 222 LOG("------ Send SIGURG 2"); 223 kill(pid, SIGURG); 224 Msleep(50); 225 LOG("------ Send SIGURG 3"); 226 kill(pid, SIGURG); 227 Msleep(50); 228 WaitProcExitedOK(pid); 229 } 230} 231 232/** 233 * @tc.number SUB_KERNEL_IPC_SIG_RAISE_0100 234 * @tc.name raise basic function test 235 * @tc.desc [C- SOFTWARE -0200] 236 */ 237HWTEST_F(IpcSignalTest, testRaiseBasic, Function | MediumTest | Level1) 238{ 239 pid_t pid = fork(); 240 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 241 if (pid == 0) { // child 242 int exitCode = 0; 243 signal(SIGQUIT, SignalHandler); 244 raise(SIGQUIT); 245 if (mReceivedSignal != SIGQUIT) { 246 LOG("Received signal check fail, expected signal=%d", SIGQUIT); 247 exitCode = 1; 248 } 249 exit(exitCode); 250 } else { // parent 251 Msleep(30); 252 WaitProcExitedOK(pid); 253 } 254} 255 256/** 257 * @tc.number SUB_KERNEL_IPC_SIG_ABORT_0100 258 * @tc.name abort function test: SIGABRT handler 259 * @tc.desc [C- SOFTWARE -0200] 260 */ 261HWTEST_F(IpcSignalTest, testAbortHandler, Function | MediumTest | Level1) 262{ 263 const int memSize = 32; 264 mShmid = shmget(IPC_PRIVATE, memSize, 0666 | IPC_CREAT); 265 if (mShmid == -1){ 266 LOG("shmget errno = %d\n", errno); 267 ADD_FAILURE(); 268 } 269 270 pid_t pid = fork(); 271 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 272 if (pid == 0) { // child 273 Msleep(30); 274 signal(SIGABRT, SigAbortHandler); 275 // try BLOCK SIGABRT 276 sigset_t set; 277 sigemptyset(&set); 278 sigaddset(&set, SIGABRT); 279 sigprocmask(SIG_BLOCK, &set, nullptr); 280 281 LOG("before abort"); 282 abort(); 283 // should never get here 284 LOG("after abort"); 285 exit(1); 286 } else { // parent 287 Msleep(50); 288 WaitProcKilled(pid, SIGABRT); 289 290 int *shared = static_cast<int*>(shmat(mShmid, NULL, 0)); 291 if (shared == reinterpret_cast<int*>(-1)) { 292 LOG("shmat fail, errno = %d", errno); 293 ADD_FAILURE(); 294 } else if (*shared != SIGABRT) { 295 LOG("Received signal check fail, expected signal=%d", SIGABRT); 296 ADD_FAILURE(); 297 } 298 shmdt(shared); 299 shmctl(mShmid, IPC_RMID, nullptr); 300 } 301} 302 303/** 304 * @tc.number SUB_KERNEL_IPC_SIGACTION_0100 305 * @tc.name sigaction function test: read siginfo 306 * @tc.desc [C- SOFTWARE -0200] 307 */ 308HWTEST_F(IpcSignalTest, testSigactionSiginfo, Function | MediumTest | Level1) 309{ 310 pid_t pid = fork(); 311 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 312 if (pid == 0) { // child 313 int exitCode = 0; 314 struct sigaction act = {0}; 315 act.sa_sigaction = SigactionHandler; 316 sigemptyset(&act.sa_mask); 317 act.sa_flags = SA_SIGINFO; 318 int rt = sigaction(SIGALRM, &act, nullptr); 319 if (rt != 0) { 320 LOG("sigaction return fail, rt=%d", rt); 321 exit(1); 322 } 323 alarm(1); 324 Msleep(1100); 325 326 if (mReceivedSignal != SIGALRM) { 327 LOG("SigactionHandler check fail, expected signal:%d, actual:%d", SIGALRM, mReceivedSignal); 328 exit(1); 329 } 330 // other area of siginfo_t is not supported yet, test code deleted 331 LOG("child exited with code=%d", exitCode); 332 exit(exitCode); 333 } else { // parent 334 Msleep(1200); 335 WaitProcExitedOK(pid); 336 } 337} 338 339/** 340 * @tc.number SUB_KERNEL_IPC_SIGWAIT_0100 341 * @tc.name sigwait basic function test 342 * @tc.desc [C- SOFTWARE -0200] 343 */ 344HWTEST_F(IpcSignalTest, testSigwaitBasic, Function | MediumTest | Level1) 345{ 346 pid_t pid = fork(); 347 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 348 if (pid == 0) { // child 349 int rt = 0; 350 int exitCode = 0; 351 sigset_t set; 352 int sig; 353 sigemptyset(&set); 354 sigaddset(&set, SIGALRM); 355 sigaddset(&set, SIGTERM); 356 signal(SIGTERM, SignalHandler); 357 signal(SIGALRM, SignalHandler); 358 359 rt = sigwait(&set, &sig); 360 LOG("sigwait1 returned: %d, signo=%d, mReceivedSignal1: %d", rt, sig, mReceivedSignal); 361 if (mReceivedSignal != SIGALRM || sig != SIGALRM) { 362 LOG("Received signal check fail, expected signal=%d", SIGALRM); 363 exitCode = 1; 364 } 365 366 rt = sigwait(&set, &sig); 367 LOG("sigwait2 returned: %d, signo=%d, mReceivedSignal1: %d", rt, sig, mReceivedSignal); 368 if (mReceivedSignal != SIGTERM || sig != SIGTERM) { 369 LOG("Received signal check fail, expected signal=%d", SIGALRM); 370 exitCode = 1; 371 } 372 373 rt = sigwait(&set, &sig); 374 LOG("sigwait3 returned: %d, signo=%d, mReceivedSignal3: %d", rt, sig, mReceivedSignal); 375 if (mReceivedSignal != SIGALRM || sig != SIGALRM) { 376 LOG("Received signal check fail, expected signal=%d", SIGALRM); 377 exitCode = 1; 378 } 379 380 LOG("child exited with code=%d", exitCode); 381 exit(exitCode); 382 } else { // parent 383 Msleep(30); 384 LOG("calling kill 1, signo=%d", SIGALRM); 385 kill(pid, SIGALRM); 386 Msleep(50); 387 LOG("calling kill 2, signo=%d", SIGTERM); 388 kill(pid, SIGTERM); 389 Msleep(50); 390 LOG("calling kill 3, signo=%d", SIGALRM); 391 kill(pid, SIGALRM); 392 Msleep(100); 393 AssertProcExitedOK(pid); 394 } 395} 396/** 397 * @tc.number SUB_KERNEL_IPC_SIGWAIT_0200 398 * @tc.name test that 'sigwait' should not return if a not-in-set signal is received 399 * @tc.desc [C- SOFTWARE -0200] 400 */ 401HWTEST_F(IpcSignalTest, testSigwaitNotInSet, Function | MediumTest | Level2) 402{ 403 pid_t pid = fork(); 404 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 405 if (pid == 0) { // child 406 int rt = 0; 407 int exitCode = 0; 408 sigset_t set; 409 int sig; 410 sigemptyset(&set); 411 sigaddset(&set, SIGTERM); 412 signal(SIGTERM, SignalHandler); 413 signal(SIGALRM, SignalHandler); 414 415 rt = sigwait(&set, &sig); 416 LOG("sigwait1 returned: %d, signo=%d, mReceivedSignal1: %d", rt, sig, mReceivedSignal); 417 LOG("child exiting with code=%d", exitCode); 418 exit(exitCode); 419 } else { // parent 420 LOG("parent pid is %d, child pid is %d", getpid(), pid); 421 Msleep(30); 422 LOG("calling kill 1, signo=%d", SIGALRM); 423 kill(pid, SIGALRM); 424 Msleep(50); 425 AssertProcAlive(pid); 426 427 LOG("calling kill 2, signo=%d", SIGKILL); 428 kill(pid, SIGKILL); 429 Msleep(100); 430 AssertProcKilled(pid, SIGKILL); 431 } 432} 433 434/** 435 * @tc.number SUB_KERNEL_IPC_SIGTIMEDWAIT_0100 436 * @tc.name sigtimedwait still work even blocked by sigprocmask 437 * @tc.desc [C- SOFTWARE -0200] 438 */ 439HWTEST_F(IpcSignalTest, testSigtimedwaitBlock, Function | MediumTest | Level1) 440{ 441 pid_t pid = fork(); 442 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 443 if (pid == 0) { // child 444 int exitCode = 0; 445 signal(SIGSEGV, SignalHandler); 446 struct timespec time1 = {0, 100*1000000}; 447 sigset_t sigmask, timeset; 448 sigemptyset(&sigmask); 449 sigaddset(&sigmask, SIGINT); 450 sigaddset(&sigmask, SIGSEGV); 451 sigemptyset(×et); 452 sigaddset(×et, SIGSEGV); 453 454 sigprocmask(SIG_BLOCK, &sigmask, nullptr); 455 Msleep(80); 456 457 int rt = sigtimedwait(×et, nullptr, &time1); 458 if (rt != SIGSEGV) { 459 LOG("sigtimedwait return fail, expected:%d, actual:%d", SIGSEGV, rt); 460 exitCode = 1; 461 } 462 463 // check the sigprocmask set not changed 464 sigemptyset(&sigmask); 465 sigprocmask(SIG_UNBLOCK, nullptr, &sigmask); 466 if (sigismember(&sigmask, SIGINT) != 1) { 467 LOG("SIGINT should still in block set!"); 468 exitCode = 1; 469 } 470 if (sigismember(&sigmask, SIGSEGV) != 1) { 471 LOG("SIGSEGV should still in block set!"); 472 exitCode = 1; 473 } 474 exit(exitCode); 475 } else { // parent 476 Msleep(40); 477 kill(pid, SIGSEGV); 478 Msleep(200); 479 WaitProcExitedOK(pid); 480 } 481 sigset_t pending; 482 sigemptyset(&pending); 483 sigpending(&pending); 484 if (sigisemptyset(&pending)) { 485 LOG("pending set empty"); 486 return; 487 } 488 LOG("========pending set not empty========="); 489 if (sigismember(&pending, SIGCHLD)) { 490 LOG("pending set is SIGCHLD"); 491 return; 492 } else { 493 LOG("pending set is not SIGCHLD!"); 494 } 495} 496 497/** 498 * @tc.number SUB_KERNEL_IPC_SIGTIMEDWAIT_0200 499 * @tc.name sigtimedwait error test: timeout or interrupted. 500 * by now, liteos sigtimedwait cannot interrupted 501 * so the interrupted-check-code will run only when 'POSIX_TEST' is set 502 * @tc.desc [C- SOFTWARE -0200] 503 */ 504HWTEST_F(IpcSignalTest, testSigtimedwaitTimeout, Function | MediumTest | Level2) 505{ 506 pid_t pid = fork(); 507 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 508 if (pid == 0) { // child 509 int rt; 510 int exitCode = 0; 511 sigset_t set; 512 siginfo_t si; 513 struct timespec ts = {0, 500*1000000}; 514 sigemptyset(&set); 515 sigaddset(&set, SIGUSR1); 516 517 struct timespec time1 = {0, 0}; 518 struct timespec time2 = {0, 0}; 519 errno = 0; 520 clock_gettime(CLOCK_MONOTONIC, &time1); 521 rt = sigtimedwait(&set, &si, &ts); 522 clock_gettime(CLOCK_MONOTONIC, &time2); 523 LOG("sigtimedwait returned: %d", rt); 524 if (rt != -1 || errno != EAGAIN) { 525 LOG("sigtimedwait error check fail, expected errno=%d(EAGAIN), actual=%d", EAGAIN, errno); 526 exitCode = 1; 527 } 528 double duration = (time2.tv_sec - time1.tv_sec)*1000.0 + (time2.tv_nsec - time1.tv_nsec)/1000000.0; 529 LOG("clock_gettime1 : tv_sec=%ld, tv_nsec=%ld", time1.tv_sec, time1.tv_nsec); 530 LOG("clock_gettime2 : tv_sec=%ld, tv_nsec=%ld", time2.tv_sec, time2.tv_nsec); 531 LOG("duration : %f ms", duration); 532 if (CheckValueClose(1000, duration)) { 533 LOG("Timeout value accuracy check fail, expected=1000, actual=%f", duration); 534 exitCode = 1; 535 } 536 537 LOG("child exited with code=%d", exitCode); 538 exit(exitCode); 539 } else { // parent 540 sleep(1); 541 WaitProcExitedOK(pid); 542 } 543} 544 545 546/** 547 * @tc.number SUB_KERNEL_IPC_SIGTIMEDWAIT_0300 548 * @tc.name sigtimedwait siginfo_t test 549 * @tc.desc [C- SOFTWARE -0200] 550 */ 551HWTEST_F(IpcSignalTest, testSigtimedwaitSiginfo, Function | MediumTest | Level2) 552{ 553 pid_t pid = fork(); 554 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 555 if (pid == 0) { // child 556 int exitCode = 0; 557 signal(SIGINT, SignalHandler); 558 struct timespec time1 = {0, 100*1000000}; 559 sigset_t set; 560 siginfo_t si; 561 sigemptyset(&set); 562 sigaddset(&set, SIGINT); 563 int rt = sigtimedwait(&set, &si, &time1); 564 if (rt != SIGINT) { 565 LOG("sigtimedwait should return the signal, expected:%d, actual:%d", SIGINT, rt); 566 exitCode = 1; 567 } 568 LOGD("si: %d,%d,%d,%p", si.si_signo, si.si_code, si.si_value.sival_int, si.si_value.sival_int); 569 if (si.si_signo != SIGINT) { 570 LOG("sigtimedwait set siginfo_t fail, si_signo=%d", si.si_signo); 571 exitCode = 1; 572 } 573 // other area of siginfo_t is not supported yet, test code deleted 574 LOG("child exited with code=%d", exitCode); 575 exit(exitCode); 576 } else { // parent 577 Msleep(20); 578 kill(pid, SIGINT); 579 Msleep(150); 580 AssertProcExitedOK(pid); 581 } 582} 583 584/** 585 * @tc.number SUB_KERNEL_IPC_SIGWAITINFO_0100 586 * @tc.name sigwaitinfo basic test: a pending signal should cause sigwaitinfo return immediately 587 * @tc.desc [C- SOFTWARE -0200] 588 */ 589HWTEST_F(IpcSignalTest, testSigwaitinfoBasic, Function | MediumTest | Level1) 590{ 591 pid_t pid = fork(); 592 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 593 if (pid == 0) { // child 594 int exitCode = 0; 595 sigset_t set, pending; 596 sigemptyset(&pending); 597 sigemptyset(&set); 598 sigaddset(&set, SIGALRM); 599 signal(SIGALRM, SignalHandler); 600 if (sigprocmask(SIG_BLOCK, &set, nullptr) == -1) { 601 LOG("sigprocmask failed"); 602 exit(1); 603 } 604 LOG("raise SIGALRM"); 605 raise(SIGALRM); 606 607 sigpending(&pending); 608 if (!sigismember(&pending, SIGALRM)) { 609 LOG("SIGALRM is not in pending set"); 610 exit(1); 611 } 612 613 LOGD("before sigwaitinfo"); 614 struct timespec time1 = {0, 0}; 615 struct timespec time2 = {0, 0}; 616 clock_gettime(CLOCK_MONOTONIC, &time1); 617 int rt = sigwaitinfo(&set, nullptr); 618 clock_gettime(CLOCK_MONOTONIC, &time2); 619 620 LOGD("after sigwaitinfo"); 621 double duration = (time2.tv_sec - time1.tv_sec)*1000.0 + (time2.tv_nsec - time1.tv_nsec)/1000000.0; 622 LOG("duration: %f ms", duration); 623 if (CheckValueClose(0.1, duration)) { 624 LOG("sigwaitinfo should return immediately, but %f ms used", duration); 625 exitCode = 1; 626 } 627 if (rt != SIGALRM) { 628 LOG("sigwaitinfo should return the signal, expected:%d, actual:%d", SIGALRM, rt); 629 exitCode = 1; 630 } 631 LOG("child exited with code=%d", exitCode); 632 exit(exitCode); 633 } else { // parent 634 sleep(1); 635 AssertProcExitedOK(pid); 636 } 637} 638 639/** 640 * @tc.number SUB_KERNEL_IPC_SIG_PAUSE_0100 641 * @tc.name pause basic function test 642 * @tc.desc [C- SOFTWARE -0200] 643 */ 644HWTEST_F(IpcSignalTest, testPauseBasic, Function | MediumTest | Level1) 645{ 646 pid_t pid = fork(); 647 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 648 if (pid == 0) { // child 649 struct timespec time1 = {0}; 650 struct timespec time2 = {0}; 651 int exitCode = 0; 652 signal(SIGQUIT, SignalHandler); 653 Msleep(100); 654 655 clock_gettime(CLOCK_MONOTONIC, &time1); 656 int rt = pause(); 657 clock_gettime(CLOCK_MONOTONIC, &time2); 658 if (rt != -1) { 659 LOG("pause should return -1, but rt=%d", rt); 660 exitCode = 1; 661 } 662 if (errno != EINTR) { 663 LOG("pause should set errno to 4(EINTR),but get %d", errno); 664 exitCode = 1; 665 } 666 667 long duration = (time2.tv_sec - time1.tv_sec)*1000 + (time2.tv_nsec - time1.tv_nsec)/1000000; 668 LOG("paused time: %ld ms", duration); 669 if (! CheckValueClose(100, duration, 0.2)) { 670 LOG("paused time check error."); 671 exitCode = 1; 672 } 673 if (mReceivedSignal != SIGQUIT) { 674 LOG("Received signal check fail, expected signal=%d", SIGQUIT); 675 exitCode = 1; 676 } 677 exit(exitCode); 678 } else { // parent 679 Msleep(200); 680 kill(pid, SIGQUIT); 681 Msleep(200); 682 AssertProcExitedOK(pid); 683 } 684} 685/** 686 * @tc.number SUB_KERNEL_IPC_SIG_PAUSE_0200 687 * @tc.name pause and mask test 688 * @tc.desc [C- SOFTWARE -0200] 689 */ 690HWTEST_F(IpcSignalTest, testPauseAndMask, Function | MediumTest | Level1) 691{ 692 pid_t pid = fork(); 693 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 694 if (pid == 0) { // child 695 int exitCode = 0; 696 signal(SIGINT, SignalHandler); 697 signal(SIGTRAP, SignalHandler); 698 699 sigset_t sigmask; 700 sigemptyset(&sigmask); 701 sigaddset(&sigmask, SIGINT); 702 int rt = sigprocmask(SIG_BLOCK, &sigmask, nullptr); 703 if (rt != 0) { 704 LOG("sigprocmask fail, rt=%d, errno=%d", rt, errno); 705 exit(1); 706 } 707 LOG("before pause"); 708 rt = pause(); 709 if (rt != -1) { 710 LOG("pause should return -1, but rt=%d", rt); 711 exitCode = 1; 712 } 713 if (errno != EINTR) { 714 LOG("pause should set errno to 4(EINTR),but get %d", errno); 715 exitCode = 1; 716 } 717 LOG("after pause"); 718 if (mReceivedSignal != SIGTRAP) { 719 LOG("Received signal check fail, expected %d,but get %d", SIGINT, mReceivedSignal); 720 exitCode = 1; 721 } 722 exit(exitCode); 723 } else { // parent 724 Msleep(20); 725 kill(pid, SIGINT); 726 Msleep(20); 727 AssertProcAlive(pid); 728 kill(pid, SIGTRAP); 729 Msleep(20); 730 WaitProcExitedOK(pid); 731 } 732 sigset_t pending; 733 sigemptyset(&pending); 734 sigpending(&pending); 735 if (sigisemptyset(&pending)) { 736 LOG("pending set empty"); 737 } else { 738 LOG("========pending set not empty========="); 739 } 740} 741 742/** 743 * @tc.number SUB_KERNEL_IPC_SIGPENDING_0100 744 * @tc.name sigpending basic function test, also test pending-signal-set should not inherited after fork, 745 but signal mask set should inherited, and the change of child's pending set should not effect parent's. 746 * @tc.desc [C- SOFTWARE -0200] 747 */ 748HWTEST_F(IpcSignalTest, testSigpendingBasic, Function | MediumTest | Level1) 749{ 750 int rt; 751 sigset_t sigmask, oldmask; 752 sigset_t pending; 753 sigemptyset(&sigmask); 754 sigemptyset(&oldmask); 755 sigemptyset(&pending); 756 sigpending(&pending); 757 EXPECT_EQ(1, sigisemptyset(&pending)) << "initial pending set should empty"; 758 759 signal(SIGALRM, SignalHandler); 760 761 sigaddset(&sigmask, SIGALRM); 762 sigaddset(&sigmask, SIGUSR1); 763 sigprocmask(SIG_BLOCK, &sigmask, &oldmask); 764 EXPECT_EQ(1, sigisemptyset(&oldmask)) << "initial sig mask set should empty"; 765 rt = sigpending(&pending); 766 EXPECT_EQ(rt, 0); 767 EXPECT_EQ(1, sigisemptyset(&pending)) << "SIG_BLOCK set should not effect on pending set"; 768 769 LOGD("raise SIGALRM"); 770 raise(SIGALRM); 771 sigpending(&pending); 772 EXPECT_EQ(1, sigismember(&pending, SIGALRM)); 773 774 pid_t pid = fork(); 775 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 776 if (pid == 0) { // child 777 int exitCode = 0; 778 sigemptyset(&pending); 779 sigpending(&pending); 780 if (sigisemptyset(&pending) != 1) { 781 LOG("pending signal set should not reserved via fork"); 782 exitCode = 1; 783 } 784 785 sigemptyset(&oldmask); 786 sigprocmask(SIG_BLOCK, nullptr, &oldmask); // read mask 787 if ((sigismember(&oldmask, SIGALRM) != 1) || (sigismember(&oldmask, SIGUSR1) != 1)) { 788 LOG("signal mask set should reserved via fork"); 789 exitCode = 1; 790 } 791 792 LOG("unblock SIGALRM."); 793 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 794 sigemptyset(&pending); 795 sigpending(&pending); 796 if (sigisemptyset(&pending) != 1) { 797 LOG("pending signal set is not empty after unblock"); 798 exitCode = 1; 799 } 800 801 LOG("child exit(%d).", exitCode); 802 exit(exitCode); 803 } else { // parent 804 Msleep(80); 805 WaitProcExitedOK(pid); 806 // check child's pending set should not effect parent's 807 sigemptyset(&pending); 808 sigpending(&pending); 809 EXPECT_EQ(1, sigismember(&pending, SIGALRM)) << "parent's pending set is changed!"; 810 } 811} 812 813/** 814 * @tc.number SUB_KERNEL_IPC_SIGPROCMASK_0100 815 * @tc.name sigprocmask function test: use raise and kill to send signal 816 * @tc.desc [C- SOFTWARE -0200] 817 */ 818HWTEST_F(IpcSignalTest, testSigprocmaskBasic, Function | MediumTest | Level1) 819{ 820 int rt; 821 sigset_t sigmask, oldmask; 822 sigset_t pending; 823 sigemptyset(&sigmask); 824 sigemptyset(&oldmask); 825 sigemptyset(&pending); 826 sigaddset(&sigmask, SIGINT); 827 sigaddset(&sigmask, SIGUSR1); 828 rt = sigprocmask(SIG_BLOCK, &sigmask, &oldmask); 829 EXPECT_EQ(rt, 0); 830 831 signal(SIGINT, SignalHandler); 832 signal(SIGUSR1, SignalHandler); 833 ASSERT_EQ(mReceivedSignal, 0); 834 835 pid_t pid = fork(); 836 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 837 if (pid == 0) { // child 838 int exitCode = 0; 839 raise(SIGINT); 840 if (mReceivedSignal != 0) { 841 LOG("SignalHandler check fail, expected=%d, actual=%d", 0, mReceivedSignal); 842 LOG("SIGINT(%d) should has blocked!", SIGINT); 843 exit(1); 844 } 845 846 LOG("unblock SIGINT"); 847 sigemptyset(&sigmask); 848 sigaddset(&sigmask, SIGINT); 849 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 850 EXPECT_EQ(rt, 0); 851 852 // check the new block set 853 sigemptyset(&oldmask); 854 sigprocmask(SIG_UNBLOCK, nullptr, &oldmask); 855 if (sigismember(&oldmask, SIGINT) == 1) { 856 LOG("SIGINT should has deleted from block set!"); 857 exitCode = 1; 858 } 859 if (sigismember(&oldmask, SIGUSR1) != 1) { 860 LOG("SIGUSR1 should still in block set!"); 861 exitCode = 1; 862 } 863 if (mReceivedSignal != SIGINT) { 864 LOG("SignalHandler check fail, expected=%d, actual=%d", SIGINT, mReceivedSignal); 865 LOG("SIGALRM should deliver after unblock!"); 866 exitCode = 1; 867 } 868 869 // test kill 870 mReceivedSignal = 0; 871 Msleep(80); 872 sigpending(&pending); 873 if (!sigismember(&pending, SIGUSR1)) { 874 LOG("SIGUSR1 is not in pending set!"); 875 exitCode = 1; 876 } else { 877 LOG("SIGUSR1 is in pending set."); 878 } 879 880 if (mReceivedSignal != 0) { 881 LOG("SignalHandler check fail, expected=%d, actual=%d", 0, mReceivedSignal); 882 LOG("SIGUSR1(%d) should has blocked!", SIGUSR1); 883 exit(1); 884 } 885 886 LOG("unblock SIGUSR1"); 887 sigemptyset(&sigmask); 888 sigaddset(&sigmask, SIGUSR1); 889 sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 890 891 if (mReceivedSignal != SIGUSR1) { 892 LOG("SignalHandler check fail, expected=%d, actual=%d", SIGUSR1, mReceivedSignal); 893 LOG("SIGUSR1 should deliver after unblock!"); 894 exitCode = 1; 895 } 896 897 LOG("child exit(%d).", exitCode); 898 exit(exitCode); 899 } else { // parent 900 Msleep(50); 901 kill(pid, SIGUSR1); 902 Msleep(50); 903 WaitProcExitedOK(pid); 904 } 905 // restore default config 906 signal(SIGINT, SIG_DFL); 907 signal(SIGUSR1, SIG_DFL); 908 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 909 EXPECT_EQ(rt, 0); 910} 911 912/** 913 * @tc.number SUB_KERNEL_IPC_SIGPROCMASK_0200 914 * @tc.name sigprocmask function test: use alarm to send the signal 915 * @tc.desc [C- SOFTWARE -0200] 916 */ 917HWTEST_F(IpcSignalTest, testSigprocmaskAlarm, Function | MediumTest | Level2) 918{ 919 int rt; 920 sigset_t sigmask, oldmask; 921 sigset_t pending; 922 sigemptyset(&sigmask); 923 sigemptyset(&oldmask); 924 sigemptyset(&pending); 925 sigaddset(&sigmask, SIGALRM); 926 rt = sigprocmask(SIG_BLOCK, &sigmask, &oldmask); 927 ASSERT_EQ(rt, 0); 928 929 signal(SIGALRM, SignalHandler); 930 ASSERT_EQ(mReceivedSignal, 0); 931 alarm(1); 932 Msleep(1100); 933 934 sigpending(&pending); 935 EXPECT_EQ(1, sigismember(&pending, SIGALRM)); 936 EXPECT_EQ(mReceivedSignal, 0); 937 938 LOG("unblock SIGALRM."); 939 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 940 EXPECT_EQ(rt, 0); 941 ASSERT_EQ(mReceivedSignal, SIGALRM); 942 943 signal(SIGALRM, SIG_DFL); 944} 945 946/** 947 * @tc.number SUB_KERNEL_IPC_SIGPROCMASK_0300 948 * @tc.name sigprocmask function test: mask operation 949 * @tc.desc [C- SOFTWARE -0200] 950 */ 951HWTEST_F(IpcSignalTest, testSigprocmaskSetMask, Function | MediumTest | Level2) 952{ 953 int rt; 954 sigset_t sigmask, oldmask, pending; 955 sigemptyset(&sigmask); 956 sigemptyset(&oldmask); 957 sigemptyset(&pending); 958 sigaddset(&sigmask, SIGALRM); 959 rt = sigprocmask(SIG_BLOCK, &sigmask, nullptr); 960 ASSERT_EQ(rt, 0); 961 sigemptyset(&sigmask); 962 sigaddset(&sigmask, SIGINT); 963 rt = sigprocmask(SIG_BLOCK, &sigmask, nullptr); 964 ASSERT_EQ(rt, 0); 965 966 LOG("add a new sig to block set"); 967 rt = sigprocmask(SIG_BLOCK, nullptr, &oldmask); // check 968 ASSERT_EQ(rt, 0); 969 EXPECT_EQ(1, sigismember(&oldmask, SIGALRM)); 970 EXPECT_EQ(1, sigismember(&oldmask, SIGINT)); 971 972 LOG("unblock a not-in-set sig"); 973 sigemptyset(&sigmask); 974 sigaddset(&sigmask, SIGTRAP); 975 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 976 ASSERT_EQ(rt, 0); 977 rt = sigprocmask(SIG_UNBLOCK, nullptr, &oldmask); // check 978 EXPECT_EQ(1, sigismember(&oldmask, SIGALRM)); 979 EXPECT_EQ(1, sigismember(&oldmask, SIGINT)); 980 EXPECT_EQ(0, sigismember(&oldmask, SIGTRAP)); 981 982 LOG("set new block set, clear old one"); 983 rt = sigprocmask(SIG_SETMASK, &sigmask, nullptr); 984 ASSERT_EQ(rt, 0); 985 rt = sigprocmask(10, nullptr, &oldmask); // check 986 ASSERT_EQ(rt, 0); 987 EXPECT_EQ(0, sigismember(&oldmask, SIGALRM)); 988 EXPECT_EQ(0, sigismember(&oldmask, SIGINT)); 989 EXPECT_EQ(1, sigismember(&oldmask, SIGTRAP)); 990 991 LOG("unblock git, clear the block set"); 992 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 993 ASSERT_EQ(rt, 0); 994 rt = sigprocmask(100, nullptr, &oldmask); // check 995 ASSERT_EQ(rt, 0); 996 EXPECT_EQ(1, sigisemptyset(&oldmask)); 997} 998/** 999 * @tc.number SUB_KERNEL_IPC_SIGPROCMASK_0400 1000 * @tc.name sigprocmask function test: don't block signal that not in block-set with caught 1001 * @tc.desc [C- SOFTWARE -0200] 1002 */ 1003HWTEST_F(IpcSignalTest, testSigprocmaskNotinSet, Function | MediumTest | Level2) 1004{ 1005 LOG("Test: not-in-set signal could be caught."); 1006 pid_t pid = fork(); 1007 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1008 if (pid == 0) { // child 1009 sigset_t sigmask; 1010 sigemptyset(&sigmask); 1011 sigaddset(&sigmask, SIGTRAP); 1012 int rt = sigprocmask(SIG_BLOCK, &sigmask, nullptr); 1013 if (rt != 0) { 1014 LOG("sigprocmask fail, rt=%d, errno=%d", rt, errno); 1015 exit(1); 1016 } 1017 signal(SIGINT, SignalHandler); 1018 signal(SIGTRAP, SignalHandler); 1019 1020 Msleep(80); 1021 if (mReceivedSignal != SIGINT) { 1022 LOG("SignalHandler check fail, expected=SIGINT, actual=%d", mReceivedSignal); 1023 exit(1); 1024 } 1025 exit(0); 1026 } else { // parent 1027 Msleep(30); 1028 kill(pid, SIGINT); 1029 Msleep(50); 1030 WaitProcExitedOK(pid); 1031 } 1032} 1033 1034/** 1035 * @tc.number SUB_KERNEL_IPC_SIGPROCMASK_0800 1036 * @tc.name sigprocmask function test: don't block signal that not in block-set with terminate 1037 * @tc.desc [C- SOFTWARE -0200] 1038 */ 1039HWTEST_F(IpcSignalTest, testSigprocmaskNotinSet0800, Function | MediumTest | Level2) 1040{ 1041 LOG("Test: not-in-set signal could terminate the process."); 1042 pid_t pid = fork(); 1043 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1044 if (pid == 0) { // child 1045 sigset_t sigmask; 1046 sigemptyset(&sigmask); 1047 sigaddset(&sigmask, SIGTRAP); 1048 int rt = sigprocmask(SIG_BLOCK, &sigmask, nullptr); 1049 if (rt != 0) { 1050 LOG("sigprocmask fail, rt=%d, errno=%d", rt, errno); 1051 exit(1); 1052 } 1053 Msleep(60); 1054 exit(0); 1055 } else { // parent 1056 Msleep(30); 1057 kill(pid, SIGINT); 1058 Msleep(30); 1059 WaitProcKilled(pid, SIGINT); 1060 } 1061} 1062 1063/** 1064 * @tc.number SUB_KERNEL_IPC_SIGSUSPEND_0100 1065 * @tc.name sigsuspend basic function test1: the sigsuspend-signal terminates the process 1066 * @tc.desc [C- SOFTWARE -0200] 1067 */ 1068HWTEST_F(IpcSignalTest, testSigsuspendTerminate, Function | MediumTest | Level1) 1069{ 1070 pid_t pid = fork(); 1071 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1072 if (pid == 0) { // child 1073 signal(SIGTRAP, SignalHandler); 1074 sigset_t set; 1075 sigemptyset(&set); 1076 sigaddset(&set, SIGHUP); 1077 int rt = sigsuspend(&set); 1078 // should not get here: 1079 LOG("sigsuspend rt = %d, errno=%d", rt, errno); 1080 exit(1); 1081 } else { // parent 1082 Msleep(20); 1083 1084 kill(pid, SIGHUP); // this should blocked by sigsuspend 1085 Msleep(20); 1086 AssertProcAlive(pid); 1087 1088 kill(pid, SIGTRAP); // this should interrupt sigsuspend 1089 Msleep(100); 1090 WaitProcKilled(pid, SIGHUP); 1091 } 1092} 1093/** 1094 * @tc.number SUB_KERNEL_IPC_SIGSUSPEND_0200 1095 * @tc.name sigsuspend basic function test2: the sigsuspend-signal caught, and process continue run 1096 * @tc.desc [C- SOFTWARE -0200] 1097 */ 1098HWTEST_F(IpcSignalTest, testSigsuspendContinue, Function | MediumTest | Level2) 1099{ 1100 pid_t pid = fork(); 1101 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1102 if (pid == 0) { // child 1103 int exitCode = 0; 1104 signal(SIGTRAP, SignalHandler); 1105 signal(SIGHUP, SignalHandler); 1106 sigset_t set; 1107 sigemptyset(&set); 1108 sigaddset(&set, SIGHUP); 1109 int rt = sigsuspend(&set); 1110 if (rt != -1) { 1111 LOG("sigsuspend should return -1, but rt=%d", rt); 1112 exitCode = 1; 1113 } 1114 if (errno != EINTR) { 1115 LOG("sigsuspend should set errno to 4(EINTR),but get %d", errno); 1116 exitCode = 1; 1117 } 1118 if (mReceivedSignal != SIGHUP) { 1119 LOG("Received signal check fail, expected signal=%d", SIGHUP); 1120 exitCode = 1; 1121 } 1122 exit(exitCode); 1123 } else { // parent 1124 Msleep(20); 1125 1126 kill(pid, SIGHUP); 1127 Msleep(20); 1128 AssertProcAlive(pid); 1129 1130 kill(pid, SIGTRAP); 1131 Msleep(100); 1132 AssertProcExitedOK(pid); 1133 } 1134} 1135 1136/** 1137 * @tc.number SUB_KERNEL_IPC_SIGSUSPEND_0300 1138 * @tc.name sigsuspend test with sigprocmask 1139 * @tc.desc [C- SOFTWARE -0200] 1140 */ 1141HWTEST_F(IpcSignalTest, testSigsuspendAndMask, Function | MediumTest | Level1) 1142{ 1143 pid_t pid = fork(); 1144 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1145 if (pid == 0) { // child 1146 int exitCode = 0; 1147 sigset_t procMask, suspendMask; 1148 sigemptyset(&suspendMask); 1149 sigemptyset(&procMask); 1150 sigaddset(&suspendMask, SIGQUIT); 1151 sigaddset(&procMask, SIGINT); 1152 1153 signal(SIGINT, SignalHandler); 1154 signal(SIGQUIT, SignalHandler); 1155 1156 LOG("Block SIGINT..."); 1157 int rt = sigprocmask(SIG_SETMASK, &procMask, nullptr); 1158 if (rt != 0) { 1159 LOG("sigprocmask fail, rt=%d, errno=%d", rt, errno); 1160 exit(1); 1161 } 1162 LOG("Suspend SIGQUIT..."); 1163 rt = sigsuspend(&suspendMask); 1164 if (rt != -1) { 1165 LOG("sigsuspend should return -1, but rt=%d", rt); 1166 exitCode = 1; 1167 } 1168 // signal in procmask should received 1st 1169 // need change to check SIGQUIT only if multi-signal issue fixed 1170 if ((mReceivedSignal != SIGQUIT) && (mReceivedSignal != SIGINT)) { 1171 LOG("Received signal check fail, get %d", mReceivedSignal); 1172 exitCode = 1; 1173 } 1174 1175 LOG("Check current mask..."); 1176 sigemptyset(&procMask); 1177 sigprocmask(10, nullptr, &procMask); 1178 if (!sigismember(&procMask, SIGINT)) { 1179 LOG("SIGINT should in block set!"); 1180 exitCode = 1; 1181 } 1182 if (sigismember(&procMask, SIGQUIT)) { 1183 LOG("SIGQUIT should not in block set!"); 1184 exitCode = 1; 1185 } 1186 exit(exitCode); 1187 } else { // parent 1188 Msleep(20); 1189 kill(pid, SIGQUIT); 1190 Msleep(20); 1191 AssertProcAlive(pid); 1192 1193 kill(pid, SIGINT); // this should interrupt sigsuspend 1194 Msleep(100); 1195 AssertProcExitedOK(pid); 1196 } 1197} 1198 1199/** 1200 * @tc.number SUB_KERNEL_IPC_SIG_PTDKILL_0100 1201 * @tc.name pthread_kill function test: basic 1202 * @tc.desc [C- SOFTWARE -0200] 1203 */ 1204HWTEST_F(IpcSignalTest, testPthreadkill, Function | MediumTest | Level1) 1205{ 1206 pthread_t tid; 1207 int sigNo = SIGXCPU; 1208 int ret = pthread_create(&tid, NULL, ThreadFunc1, (void*)sigNo); 1209 ASSERT_EQ(ret, 0) << "pthread_create failed, errno=" << ret; 1210 Msleep(30); 1211 ret = pthread_kill(tid, sigNo); 1212 EXPECT_EQ(ret, 0) << "pthread_kill failed, errno=" << ret; 1213 ret = pthread_join(tid, NULL); 1214 EXPECT_EQ(ret, 0) << "pthread_join failed, errno=" << ret; 1215 EXPECT_EQ(mReceivedSignal, sigNo) << "Thread received signal check fail"; 1216 // restore handler 1217 handler_type rt = signal(sigNo, SIG_DFL); 1218 ASSERT_NE(rt, SIG_ERR) << "restore signal failed, errno=" << errno; 1219} 1220 1221/** 1222 * @tc.number SUB_KERNEL_IPC_SIG_PTDKILL_0200 1223 * @tc.name pthread_kill function test: try kill main thread 1224 * @tc.desc [C- SOFTWARE -0200] 1225 */ 1226HWTEST_F(IpcSignalTest, testPthreadkillMain, Function | MediumTest | Level2) 1227{ 1228 pid_t pid = fork(); 1229 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1230 if (pid == 0) { // child 1231 pthread_t mainThread = pthread_self(); 1232 signal(SIGINT, SignalHandler); 1233 pthread_t tid; 1234 int ret = pthread_create(&tid, NULL, ThreadFunc2, &mainThread); 1235 if (ret != 0) { 1236 LOG("pthread_create failed, errno=%d", ret); 1237 exit(1); 1238 } 1239 1240 void* threadExitCode = nullptr; 1241 ret = pthread_join(tid, &threadExitCode); 1242 if (ret != 0) { 1243 LOG("pthread_join failed, errno=%d", ret); 1244 exit(1); 1245 } 1246 int c = (int)((uintptr_t)threadExitCode); 1247 if (c != 0) { 1248 LOG("sub thread exited failed, code=%d", c); 1249 exit(1); 1250 } 1251 1252 if (mReceivedSignal != SIGINT) { 1253 LOG("SignalHandler check fail, expected signal:%d, actual:%d", SIGINT, mReceivedSignal); 1254 exit(1); 1255 } 1256 exit(0); 1257 } else { // parent 1258 Msleep(100); 1259 AssertProcExitedOK(pid); 1260 } 1261} 1262 1263/** 1264 * @tc.number SUB_KERNEL_IPC_SIG_PTDSIGMASK_0100 1265 * @tc.name pthread_sigmask function test: basic 1266 * @tc.desc [C- SOFTWARE -0200] 1267 */ 1268HWTEST_F(IpcSignalTest, testPthreadSigmask, Function | MediumTest | Level1) 1269{ 1270 pthread_t tid; 1271 int ret = pthread_create(&tid, NULL, ThreadFuncForSigmask1, (void*)1); 1272 ASSERT_EQ(ret, 0) << "pthread_create failed, errno=" << ret; 1273 ret = pthread_join(tid, NULL); 1274 EXPECT_EQ(ret, 0) << "pthread_join failed, errno=" << ret; 1275} 1276 1277/** 1278 * @tc.number SUB_KERNEL_IPC_SIG_PTDSIGMASK_0200 1279 * @tc.name pthread_sigmask function test: handler 1280 * @tc.desc [C- SOFTWARE -0200] 1281 */ 1282HWTEST_F(IpcSignalTest, testPthreadSigmaskHandler, Function | MediumTest | Level1) 1283{ 1284 signal(SIGINT, SignalHandler); 1285 pthread_t tid; 1286 int ret = pthread_create(&tid, NULL, ThreadFuncForSigmask1, (void*)2); 1287 EXPECT_EQ(ret, 0) << "pthread_create failed, errno=" << ret; 1288 1289 ret = pthread_join(tid, NULL); 1290 EXPECT_EQ(ret, 0) << "pthread_join failed, errno=" << ret; 1291 1292 signal(SIGINT, SIG_DFL); 1293} 1294 1295/** 1296 * @tc.number SUB_KERNEL_IPC_SIG_PTDSIGMASK_0300 1297 * @tc.name test that the signal-mask should inherited from the creator 1298 * @tc.desc [C- SOFTWARE -0200] 1299 */ 1300HWTEST_F(IpcSignalTest, testPthreadSigmaskInherit, Function | MediumTest | Level3) 1301{ 1302 sigset_t sigmask, oldmask; 1303 sigemptyset(&sigmask); 1304 sigemptyset(&oldmask); 1305 1306 LOG("add SIGUSR1 to block set"); 1307 sigaddset(&sigmask, SIGUSR1); 1308 int rt = sigprocmask(SIG_BLOCK, &sigmask, &oldmask); 1309 EXPECT_EQ(rt, 0); 1310 1311 pthread_t tid; 1312 int ret = pthread_create(&tid, NULL, ThreadFuncForSigmask2, NULL); 1313 EXPECT_EQ(ret, 0) << "pthread_create failed, errno=" << ret; 1314 1315 void* threadExitCode = nullptr; 1316 ret = pthread_join(tid, &threadExitCode); 1317 EXPECT_EQ(ret, 0) << "pthread_join failed, errno=" << ret; 1318 int code = (int)((uintptr_t)threadExitCode); 1319 EXPECT_EQ(code, 0); 1320 1321 LOG("check the block set is not effected"); 1322 sigprocmask(SIG_UNBLOCK, nullptr, &oldmask); 1323 1324 EXPECT_EQ(sigismember(&oldmask, SIGINT), 0) << "SIGINT should not in block set!"; 1325 EXPECT_EQ(sigismember(&oldmask, SIGUSR1), 1) << "SIGUSR1 should still in block set!"; 1326 1327 LOG("restore default config"); 1328 rt = sigprocmask(SIG_UNBLOCK, &sigmask, nullptr); 1329 EXPECT_EQ(rt, 0); 1330} 1331 1332/** 1333 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0100 1334 * @tc.name test sig set operator APIs:sigemptyset,sigaddset,sigisemptyset,sigismember 1335 * @tc.desc [C- SOFTWARE -0200] 1336 */ 1337HWTEST_F(IpcSignalTest, testSigsetBasic, Function | MediumTest | Level2) 1338{ 1339 sigset_t set; 1340 int rt = sigemptyset(&set); 1341 EXPECT_EQ(rt, 0) << "sigandset failed"; 1342 EXPECT_EQ(sigisemptyset(&set), 1) << "set should empty"; 1343 1344 rt = sigaddset(&set, SIGINT); 1345 EXPECT_EQ(rt, 0) << "sigaddset failed, errno=" << errno; 1346 EXPECT_EQ(sigismember(&set, SIGINT), 1) << "SIGINT should in set"; 1347 EXPECT_EQ(sigismember(&set, SIGQUIT), 0) << "SIGQUIT should not in set"; 1348 1349 rt = sigaddset(&set, SIGQUIT); 1350 EXPECT_EQ(rt, 0) << "sigaddset failed, errno=" << errno; 1351 EXPECT_EQ(sigismember(&set, SIGQUIT), 1) << "SIGQUIT should in set"; 1352 1353 rt = sigaddset(&set, -1); 1354 EXPECT_EQ(rt, -1); 1355 EXPECT_EQ(errno, EINVAL); 1356 1357 rt = sigaddset(&set, MAX_SIGNAL_NUMBER + 1); 1358 EXPECT_EQ(rt, -1); 1359 EXPECT_EQ(errno, EINVAL); 1360 1361 LOG("check that set not changed after failed-sigadd"); 1362 EXPECT_EQ(sigismember(&set, SIGINT), 1) << "SIGINT should in set"; 1363 EXPECT_EQ(sigismember(&set, SIGQUIT), 1) << "SIGQUIT should in set"; 1364 1365 sigemptyset(&set); 1366 EXPECT_EQ(sigisemptyset(&set), 1) << "set should empty"; 1367} 1368 1369/** 1370 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0200 1371 * @tc.name test sig set operator API: sigandset 1372 * @tc.desc [C- SOFTWARE -0200] 1373 */ 1374HWTEST_F(IpcSignalTest, testSigsetAnd, Function | MediumTest | Level2) 1375{ 1376 sigset_t set1, set2, setAnd; 1377 sigemptyset(&set1); 1378 sigemptyset(&set2); 1379 sigemptyset(&setAnd); 1380 int rt; 1381 1382 LOG("test and-set with empty set:"); 1383 sigaddset(&set1, SIGINT); 1384 rt = sigandset(&setAnd, &set1, &set2); 1385 EXPECT_EQ(rt, 0) << "sigandset failed, errno=" << errno; 1386 EXPECT_EQ(sigisemptyset(&setAnd), 1) << "setAnd should empty"; 1387} 1388 1389/** 1390 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0300 1391 * @tc.name test sig set operator API: sigorset 1392 * @tc.desc [C- SOFTWARE -0200] 1393 */ 1394HWTEST_F(IpcSignalTest, testSigsetOr, Function | MediumTest | Level2) 1395{ 1396 sigset_t set1, set2, setOr; 1397 sigemptyset(&set1); 1398 sigemptyset(&set2); 1399 sigemptyset(&setOr); 1400 int rt; 1401 1402 LOG("test or-set with empty set:"); 1403 sigaddset(&set1, SIGINT); 1404 rt = sigorset(&setOr, &set1, &set2); 1405 EXPECT_EQ(rt, 0) << "sigorset failed, errno=" << errno; 1406 EXPECT_EQ(sigismember(&setOr, SIGINT), 1) << "SIGINT should in setOr"; 1407} 1408 1409/** 1410 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0400 1411 * @tc.name test sig set operator APIs: sigdelset 1412 * @tc.desc [C- SOFTWARE -0200] 1413 */ 1414HWTEST_F(IpcSignalTest, testSigsetDelete, Function | MediumTest | Level2) 1415{ 1416 sigset_t set; 1417 sigemptyset(&set); 1418 sigaddset(&set, SIGINT); 1419 1420 LOG("delete in-set sig:"); 1421 int rt = sigdelset(&set, SIGINT); 1422 EXPECT_EQ(rt, 0) << "sigdelset failed, errno=" << errno; 1423 EXPECT_EQ(sigisemptyset(&set), 1); 1424 1425 sigaddset(&set, SIGINT); 1426 sigaddset(&set, SIGQUIT); 1427 rt = sigdelset(&set, SIGINT); 1428 EXPECT_EQ(rt, 0) << "sigdelset failed, errno=" << errno; 1429 EXPECT_EQ(sigismember(&set, SIGQUIT), 1) << "SIGQUIT should in set"; 1430 EXPECT_EQ(sigismember(&set, SIGINT), 0) << "SIGINT should not in set"; 1431} 1432 1433/** 1434 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0500 1435 * @tc.name test sig set operator APIs: sigfillset 1436 * @tc.desc [C- SOFTWARE -0200] 1437 */ 1438HWTEST_F(IpcSignalTest, testSigsetFill, Function | MediumTest | Level2) 1439{ 1440 sigset_t set; 1441 sigemptyset(&set); 1442 sigaddset(&set, SIGINT); 1443 1444 int rt = sigfillset(&set); 1445 EXPECT_EQ(rt, 0) << "sigfillset failed, errno=" << errno; 1446 for (int i = 1; i <= MAX_SIGNAL; i++) { 1447 EXPECT_EQ(sigismember(&set, i), 1) << i << " not in set!"; 1448 } 1449 1450 sigdelset(&set, SIGINT); 1451 for (int i = 1; i <= MAX_SIGNAL; i++) { 1452 if (i == SIGINT) { 1453 EXPECT_EQ(sigismember(&set, i), 0) << "SIGINT should not in set!"; 1454 } else { 1455 EXPECT_EQ(sigismember(&set, i), 1) << i << " not in set!"; 1456 } 1457 } 1458} 1459 1460/** 1461 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0600 1462 * @tc.name test sigdelset operator APIs: sigdelset 1463 * @tc.desc [C- SOFTWARE -0200] 1464 */ 1465HWTEST_F(IpcSignalTest, testSigsetDelete0600, Function | MediumTest | Level2) 1466{ 1467 int rt; 1468 sigset_t set; 1469 sigemptyset(&set); 1470 sigaddset(&set, SIGINT); 1471 1472 LOG("delete not-in-set sig:"); 1473 sigemptyset(&set); 1474 sigaddset(&set, SIGQUIT); 1475 rt = sigdelset(&set, SIGINT); 1476 EXPECT_EQ(rt, 0) << "sigdelset failed, errno=" << errno; 1477 EXPECT_EQ(sigismember(&set, SIGQUIT), 1) << "SIGQUIT should in set"; 1478 EXPECT_EQ(sigismember(&set, SIGINT), 0) << "SIGINT should not in set"; 1479} 1480 1481/** 1482 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_0700 1483 * @tc.name test sig set operator APIs: sigdelset with invalid 1484 * @tc.desc [C- SOFTWARE -0200] 1485 */ 1486HWTEST_F(IpcSignalTest, testSigsetDelete0700, Function | MediumTest | Level2) 1487{ 1488 int rt; 1489 sigset_t set; 1490 sigemptyset(&set); 1491 sigaddset(&set, SIGINT); 1492 1493 LOG("delete invalid sig:"); 1494 rt = sigdelset(&set, -1); 1495 EXPECT_EQ(rt, -1); 1496 EXPECT_EQ(errno, EINVAL); 1497 1498 rt = sigdelset(&set, MAX_SIGNAL_NUMBER + 1); 1499 EXPECT_EQ(rt, -1); 1500 EXPECT_EQ(errno, EINVAL); 1501 1502 LOG("check that set not changed after failed-delete"); 1503 EXPECT_EQ(sigismember(&set, SIGQUIT), 0) << "SIGQUIT should in set"; 1504 EXPECT_EQ(sigismember(&set, SIGINT), 1) << "SIGINT should not in set"; 1505} 1506 1507/** 1508 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_1000 1509 * @tc.name test sig set operator API: sigorset with non-overlap 1510 * @tc.desc [C- SOFTWARE -0200] 1511 */ 1512HWTEST_F(IpcSignalTest, testSigsetOr1000, Function | MediumTest | Level2) 1513{ 1514 sigset_t set1, set2, setOr; 1515 sigemptyset(&set1); 1516 sigemptyset(&set2); 1517 sigemptyset(&setOr); 1518 int rt; 1519 1520 LOG("test or-set with non-overlap sets:"); 1521 sigaddset(&set1, SIGINT); 1522 sigaddset(&set2, SIGABRT); 1523 rt = sigorset(&setOr, &set1, &set2); 1524 EXPECT_EQ(rt, 0) << "sigorset failed, errno=" << errno; 1525 EXPECT_EQ(sigismember(&setOr, SIGINT), 1) << "SIGINT should in setOr"; 1526 EXPECT_EQ(sigismember(&setOr, SIGABRT), 1) << "SIGABRT should in setOr"; 1527} 1528 1529/** 1530 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_1100 1531 * @tc.name test sig set operator API: sigorset with overlapping 1532 * @tc.desc [C- SOFTWARE -0200] 1533 */ 1534HWTEST_F(IpcSignalTest, testSigsetOr1100, Function | MediumTest | Level2) 1535{ 1536 sigset_t set1, set2, setOr; 1537 sigemptyset(&set1); 1538 sigemptyset(&set2); 1539 sigemptyset(&setOr); 1540 int rt; 1541 1542 LOG("test or-set with overlapping sets:"); 1543 sigaddset(&setOr, SIGHUP); // original siganl in setOr 1544 sigaddset(&set1, SIGINT); 1545 sigaddset(&set2, SIGABRT); 1546 sigaddset(&set1, SIGQUIT); 1547 sigaddset(&set2, SIGQUIT); 1548 rt = sigorset(&setOr, &set1, &set2); 1549 EXPECT_EQ(rt, 0) << "sigorset failed, errno=" << errno; 1550 EXPECT_EQ(sigismember(&setOr, SIGINT), 1) << "SIGINT should in setOr"; 1551 EXPECT_EQ(sigismember(&setOr, SIGABRT), 1) << "SIGABRT should in setOr"; 1552 EXPECT_EQ(sigismember(&setOr, SIGQUIT), 1) << "SIGQUIT should in setOr"; 1553 EXPECT_EQ(sigismember(&setOr, SIGHUP), 0) << "original siganl in setOr should deleted"; 1554} 1555 1556 1557/** 1558 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_1200 1559 * @tc.name test sig set operator API: sigandset with non-overlap 1560 * @tc.desc [C- SOFTWARE -0200] 1561 */ 1562HWTEST_F(IpcSignalTest, testSigsetAnd1200, Function | MediumTest | Level2) 1563{ 1564 sigset_t set1, set2, setAnd; 1565 sigemptyset(&set1); 1566 sigemptyset(&set2); 1567 sigemptyset(&setAnd); 1568 int rt; 1569 1570 LOG("test and-set with non-overlap sets:"); 1571 sigaddset(&set1, SIGINT); 1572 sigaddset(&set2, SIGABRT); 1573 rt = sigandset(&setAnd, &set1, &set2); 1574 EXPECT_EQ(rt, 0) << "sigandset failed, errno=" << errno; 1575 EXPECT_EQ(sigisemptyset(&setAnd), 1) << "setAnd should empty"; 1576} 1577 1578/** 1579 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_1300 1580 * @tc.name test sig set operator API: sigandset with overlapping 1581 * @tc.desc [C- SOFTWARE -0200] 1582 */ 1583HWTEST_F(IpcSignalTest, testSigsetAnd1300, Function | MediumTest | Level2) 1584{ 1585 sigset_t set1, set2, setAnd; 1586 sigemptyset(&set1); 1587 sigemptyset(&set2); 1588 sigemptyset(&setAnd); 1589 int rt; 1590 1591 LOG("test and-set with overlapping sets:"); 1592 sigaddset(&set1, SIGINT); 1593 sigaddset(&set2, SIGABRT); 1594 sigaddset(&set1, SIGQUIT); 1595 sigaddset(&set2, SIGQUIT); 1596 sigaddset(&setAnd, SIGHUP); // original siganl in setAnd 1597 rt = sigandset(&setAnd, &set1, &set2); 1598 EXPECT_EQ(rt, 0) << "sigandset failed, errno=" << errno; 1599 EXPECT_EQ(sigismember(&setAnd, SIGQUIT), 1) << "SIGQUIT should in setAnd"; 1600 EXPECT_EQ(sigismember(&setAnd, SIGINT), 0) << "SIGINT should not in setAnd"; 1601 EXPECT_EQ(sigismember(&setAnd, SIGABRT), 0) << "SIGABRT should not in setAnd"; 1602 EXPECT_EQ(sigismember(&setAnd, SIGHUP), 0) << "original siganl in setAnd should deleted"; 1603} 1604 1605/** 1606 * @tc.number SUB_KERNEL_IPC_SIG_SETOP_1400 1607 * @tc.name test sig set operator API: sigandset with multi-overlapping 1608 * @tc.desc [C- SOFTWARE -0200] 1609 */ 1610HWTEST_F(IpcSignalTest, testSigsetAnd1400, Function | MediumTest | Level2) 1611{ 1612 sigset_t set1, set2, setAnd; 1613 sigemptyset(&set1); 1614 sigemptyset(&set2); 1615 sigemptyset(&setAnd); 1616 int rt; 1617 LOG("test and-set with multi-overlapping sets:"); 1618 sigaddset(&set1, SIGINT); 1619 sigaddset(&set2, SIGABRT); 1620 sigaddset(&set1, SIGQUIT); 1621 sigaddset(&set2, SIGQUIT); 1622 sigaddset(&setAnd, SIGHUP); // original siganl in setAnd 1623 sigaddset(&set1, SIGUSR1); 1624 sigaddset(&set2, SIGUSR1); 1625 rt = sigandset(&setAnd, &set1, &set2); 1626 EXPECT_EQ(rt, 0) << "sigandset failed, errno=" << errno; 1627 EXPECT_EQ(sigismember(&setAnd, SIGQUIT), 1) << "SIGQUIT should in setAnd"; 1628 EXPECT_EQ(sigismember(&setAnd, SIGUSR1), 1) << "SIGUSR1 should in setAnd"; 1629 EXPECT_EQ(sigismember(&setAnd, SIGINT), 0) << "SIGINT should not in setAnd"; 1630 EXPECT_EQ(sigismember(&setAnd, SIGABRT), 0) << "SIGABRT should not in setAnd"; 1631} 1632 1633/** 1634 * @tc.number SUB_KERNEL_IPC_SIG_SIGHOLD_0100 1635 * @tc.name sighold function test 1636 * @tc.desc [C- SOFTWARE -0200] 1637 */ 1638HWTEST_F(IpcSignalTest, testSigHold, Function | MediumTest | Level2) 1639{ 1640 int sigNo = SIGINT; 1641 int rt = sighold(sigNo); 1642 ASSERT_EQ(rt, 0) << "sighold failed, errno=" << errno; 1643 1644 LOG("check that the signal is added to the mask"); 1645 sigset_t oldmask; 1646 sigemptyset(&oldmask); 1647 rt = sigprocmask(SIG_BLOCK, nullptr, &oldmask); 1648 EXPECT_EQ(rt, 0); 1649 EXPECT_EQ(sigismember(&oldmask, sigNo), 1); 1650 1651 // restore default config 1652 rt = sigprocmask(SIG_UNBLOCK, &oldmask, nullptr); 1653 EXPECT_EQ(rt, 0); 1654} 1655 1656/** 1657 * @tc.number SUB_KERNEL_IPC_SIG_SIGHOLD_0200 1658 * @tc.name sighold function error test 1659 * @tc.desc [C- SOFTWARE -0200] 1660 */ 1661HWTEST_F(IpcSignalTest, testSigHoldError, Function | MediumTest | Level2) 1662{ 1663 int rt = sighold(-1); 1664 EXPECT_EQ(rt, -1); 1665 EXPECT_EQ(errno, EINVAL); 1666 1667 rt = sighold(MAX_SIGNAL_NUMBER + 1); 1668 EXPECT_EQ(rt, -1); 1669 EXPECT_EQ(errno, EINVAL); 1670} 1671 1672/** 1673 * @tc.number SUB_KERNEL_IPC_SIG_SIGRELSE_0100 1674 * @tc.name sigrelse function test 1675 * @tc.desc [C- SOFTWARE -0200] 1676 */ 1677HWTEST_F(IpcSignalTest, testSigRelse, Function | MediumTest | Level2) 1678{ 1679 LOG("add sig to mask"); 1680 sigset_t mask; 1681 sigemptyset(&mask); 1682 sigaddset(&mask, SIGINT); 1683 int rt = sigprocmask(SIG_BLOCK, &mask, nullptr); 1684 ASSERT_EQ(rt, 0); 1685 1686 LOG("delete signal from the mask"); 1687 rt = sigrelse(SIGINT); 1688 EXPECT_EQ(rt, 0); 1689 1690 LOG("check that the signal is deleted"); 1691 sigemptyset(&mask); 1692 rt = sigprocmask(SIG_BLOCK, nullptr, &mask); 1693 EXPECT_EQ(rt, 0); 1694 EXPECT_EQ(sigisemptyset(&mask), 1); 1695} 1696 1697/** 1698 * @tc.number SUB_KERNEL_IPC_SIG_SIGRELSE_0200 1699 * @tc.name sigrelse function error test 1700 * @tc.desc [C- SOFTWARE -0200] 1701 */ 1702HWTEST_F(IpcSignalTest, testSigRelseError, Function | MediumTest | Level2) 1703{ 1704 int rt = sigrelse(-1); 1705 EXPECT_EQ(rt, -1); 1706 EXPECT_EQ(errno, EINVAL); 1707 1708 rt = sigrelse(MAX_SIGNAL_NUMBER + 1); 1709 EXPECT_EQ(rt, -1); 1710 EXPECT_EQ(errno, EINVAL); 1711} 1712 1713/** 1714 * @tc.number SUB_KERNEL_IPC_SIG_PSIGNAL_0100 1715 * @tc.name psignal function test 1716 * @tc.desc [C- SOFTWARE -0200] 1717 */ 1718HWTEST_F(IpcSignalTest, testPsignal, Function | MediumTest | Level2) 1719{ 1720 // we use child to do the test here, cause 'restore of stderr' is not work by now. 1721 pid_t pid = fork(); 1722 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1723 if (pid == 0) { // child 1724 // redirect stderr to a file, so we can check the content. 1725 char* outfile = WRITABLE_TEST_DIR "stderr.txt"; 1726 if (freopen(outfile, "w", stderr) == NULL) { 1727 LOG("redirect stderr fail, freopen errno=%d\n", errno); 1728 exit(1); 1729 } 1730 psignal(SIGFPE, "SIGFPE"); 1731 int rt = CheckSigString(outfile, "SIGFPE: Arithmetic exception"); 1732 exit(rt); 1733 } else { // parent 1734 WaitProcExitedOK(pid); 1735 } 1736} 1737 1738/** 1739 * @tc.number SUB_KERNEL_IPC_SIG_PSIGNAL_0200 1740 * @tc.name psignal function error test1 1741 * @tc.desc [C- SOFTWARE -0200] 1742 */ 1743HWTEST_F(IpcSignalTest, testPsignalError1, Function | MediumTest | Level3) 1744{ 1745 pid_t pid = fork(); 1746 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1747 if (pid == 0) { // child 1748 char* outfile = WRITABLE_TEST_DIR "stderr.txt"; 1749 if (freopen(outfile, "w", stderr) == NULL) { 1750 LOG("redirect stderr fail, freopen errno=%d\n", errno); 1751 exit(1); 1752 } 1753 psignal(-1, "==="); 1754 int rt = CheckSigString(outfile, "===: Unknown signal"); 1755 exit(rt); 1756 } else { // parent 1757 WaitProcExitedOK(pid); 1758 } 1759} 1760 1761/** 1762 * @tc.number SUB_KERNEL_IPC_SIG_PSIGNAL_0300 1763 * @tc.name psignal function error test2 1764 * @tc.desc [C- SOFTWARE -0200] 1765 */ 1766HWTEST_F(IpcSignalTest, testPsignalError2, Function | MediumTest | Level3) 1767{ 1768 pid_t pid = fork(); 1769 ASSERT_TRUE(pid >= 0) << "======== Fork Error! ========="; 1770 if (pid == 0) { // child 1771 char* outfile = WRITABLE_TEST_DIR "stderr.txt"; 1772 if (freopen(outfile, "w", stderr) == NULL) { 1773 LOG("redirect stderr fail, freopen errno=%d\n", errno); 1774 exit(1); 1775 } 1776 psignal(MAX_SIGNAL_NUMBER + 1, "***"); 1777 int rt = CheckSigString(outfile, "***: Unknown signal"); 1778 exit(rt); 1779 } else { // parent 1780 WaitProcExitedOK(pid); 1781 } 1782} 1783