LCOV - code coverage report
Current view: top level - test - test-signal-util.c (source / functions) Hit Total Coverage
Test: systemd_full.info Lines: 96 96 100.0 %
Date: 2019-08-23 13:36:53 Functions: 8 8 100.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 59 106 55.7 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: LGPL-2.1+ */
       2                 :            : 
       3                 :            : #include <signal.h>
       4                 :            : #include <unistd.h>
       5                 :            : 
       6                 :            : #include "log.h"
       7                 :            : #include "macro.h"
       8                 :            : #include "signal-util.h"
       9                 :            : #include "stdio-util.h"
      10                 :            : #include "string-util.h"
      11                 :            : #include "process-util.h"
      12                 :            : 
      13                 :            : #define info(sig) log_info(#sig " = " STRINGIFY(sig) " = %d", sig)
      14                 :            : 
      15                 :          4 : static void test_rt_signals(void) {
      16         [ +  - ]:          4 :         info(SIGRTMIN);
      17         [ +  - ]:          4 :         info(SIGRTMAX);
      18                 :            : 
      19                 :            :         /* We use signals SIGRTMIN+0 to SIGRTMIN+24 unconditionally */
      20         [ -  + ]:          4 :         assert(SIGRTMAX - SIGRTMIN >= 24);
      21                 :          4 : }
      22                 :            : 
      23                 :         20 : static void test_signal_to_string_one(int val) {
      24                 :            :         const char *p;
      25                 :            : 
      26         [ -  + ]:         20 :         assert_se(p = signal_to_string(val));
      27                 :            : 
      28         [ -  + ]:         20 :         assert_se(signal_from_string(p) == val);
      29                 :            : 
      30   [ +  +  +  -  :        100 :         p = strjoina("SIG", p);
          -  +  -  +  +  
                +  +  - ]
      31         [ -  + ]:         20 :         assert_se(signal_from_string(p) == val);
      32                 :         20 : }
      33                 :            : 
      34                 :        112 : static void test_signal_from_string_one(const char *s, int val) {
      35                 :            :         const char *p;
      36                 :            : 
      37         [ -  + ]:        112 :         assert_se(signal_from_string(s) == val);
      38                 :            : 
      39   [ +  +  +  -  :        560 :         p = strjoina("SIG", s);
          -  +  -  +  +  
                +  +  - ]
      40         [ -  + ]:        112 :         assert_se(signal_from_string(p) == val);
      41                 :        112 : }
      42                 :            : 
      43                 :         20 : static void test_signal_from_string_number(const char *s, int val) {
      44                 :            :         const char *p;
      45                 :            : 
      46         [ -  + ]:         20 :         assert_se(signal_from_string(s) == val);
      47                 :            : 
      48   [ +  +  +  -  :        100 :         p = strjoina("SIG", s);
          -  +  -  +  +  
                +  +  - ]
      49         [ -  + ]:         20 :         assert_se(signal_from_string(p) == -EINVAL);
      50                 :         20 : }
      51                 :            : 
      52                 :          4 : static void test_signal_from_string(void) {
      53                 :            :         char buf[STRLEN("RTMIN+") + DECIMAL_STR_MAX(int) + 1];
      54                 :            : 
      55                 :          4 :         test_signal_to_string_one(SIGHUP);
      56                 :          4 :         test_signal_to_string_one(SIGTERM);
      57                 :          4 :         test_signal_to_string_one(SIGRTMIN);
      58                 :          4 :         test_signal_to_string_one(SIGRTMIN+3);
      59                 :          4 :         test_signal_to_string_one(SIGRTMAX-4);
      60                 :            : 
      61                 :          4 :         test_signal_from_string_one("RTMIN", SIGRTMIN);
      62                 :          4 :         test_signal_from_string_one("RTMAX", SIGRTMAX);
      63                 :            : 
      64         [ -  + ]:          4 :         xsprintf(buf, "RTMIN+%d", SIGRTMAX-SIGRTMIN);
      65                 :          4 :         test_signal_from_string_one(buf, SIGRTMAX);
      66                 :            : 
      67         [ -  + ]:          4 :         xsprintf(buf, "RTMIN+%d", INT_MAX);
      68                 :          4 :         test_signal_from_string_one(buf, -ERANGE);
      69                 :            : 
      70         [ -  + ]:          4 :         xsprintf(buf, "RTMAX-%d", SIGRTMAX-SIGRTMIN);
      71                 :          4 :         test_signal_from_string_one(buf, SIGRTMIN);
      72                 :            : 
      73         [ -  + ]:          4 :         xsprintf(buf, "RTMAX-%d", INT_MAX);
      74                 :          4 :         test_signal_from_string_one(buf, -ERANGE);
      75                 :            : 
      76                 :          4 :         test_signal_from_string_one("", -EINVAL);
      77                 :          4 :         test_signal_from_string_one("hup", -EINVAL);
      78                 :          4 :         test_signal_from_string_one("HOGEHOGE", -EINVAL);
      79                 :            : 
      80                 :          4 :         test_signal_from_string_one("RTMIN-5", -EINVAL);
      81                 :          4 :         test_signal_from_string_one("RTMIN-    5", -EINVAL);
      82                 :          4 :         test_signal_from_string_one("RTMIN    -5", -EINVAL);
      83                 :          4 :         test_signal_from_string_one("RTMIN+    5", -EINVAL);
      84                 :          4 :         test_signal_from_string_one("RTMIN    +5", -EINVAL);
      85                 :          4 :         test_signal_from_string_one("RTMIN+100", -ERANGE);
      86                 :          4 :         test_signal_from_string_one("RTMIN+-3", -EINVAL);
      87                 :          4 :         test_signal_from_string_one("RTMIN++3", -EINVAL);
      88                 :          4 :         test_signal_from_string_one("RTMIN+HUP", -EINVAL);
      89                 :          4 :         test_signal_from_string_one("RTMIN3", -EINVAL);
      90                 :            : 
      91                 :          4 :         test_signal_from_string_one("RTMAX+5", -EINVAL);
      92                 :          4 :         test_signal_from_string_one("RTMAX+    5", -EINVAL);
      93                 :          4 :         test_signal_from_string_one("RTMAX    +5", -EINVAL);
      94                 :          4 :         test_signal_from_string_one("RTMAX-    5", -EINVAL);
      95                 :          4 :         test_signal_from_string_one("RTMAX    -5", -EINVAL);
      96                 :          4 :         test_signal_from_string_one("RTMAX-100", -ERANGE);
      97                 :          4 :         test_signal_from_string_one("RTMAX-+3", -EINVAL);
      98                 :          4 :         test_signal_from_string_one("RTMAX--3", -EINVAL);
      99                 :          4 :         test_signal_from_string_one("RTMAX-HUP", -EINVAL);
     100                 :            : 
     101                 :          4 :         test_signal_from_string_number("3", 3);
     102                 :          4 :         test_signal_from_string_number("+5", 5);
     103                 :          4 :         test_signal_from_string_number("  +5", 5);
     104                 :          4 :         test_signal_from_string_number("10000", -ERANGE);
     105                 :          4 :         test_signal_from_string_number("-2", -ERANGE);
     106                 :          4 : }
     107                 :            : 
     108                 :          4 : static void test_block_signals(void) {
     109                 :            :         sigset_t ss;
     110                 :            : 
     111         [ -  + ]:          4 :         assert_se(sigprocmask(0, NULL, &ss) >= 0);
     112                 :            : 
     113         [ -  + ]:          4 :         assert_se(sigismember(&ss, SIGUSR1) == 0);
     114         [ -  + ]:          4 :         assert_se(sigismember(&ss, SIGALRM) == 0);
     115         [ -  + ]:          4 :         assert_se(sigismember(&ss, SIGVTALRM) == 0);
     116                 :            : 
     117                 :            :         {
     118         [ -  + ]:          8 :                 BLOCK_SIGNALS(SIGUSR1, SIGVTALRM);
     119                 :            : 
     120         [ -  + ]:          4 :                 assert_se(sigprocmask(0, NULL, &ss) >= 0);
     121         [ -  + ]:          4 :                 assert_se(sigismember(&ss, SIGUSR1) == 1);
     122         [ -  + ]:          4 :                 assert_se(sigismember(&ss, SIGALRM) == 0);
     123         [ -  + ]:          4 :                 assert_se(sigismember(&ss, SIGVTALRM) == 1);
     124                 :            : 
     125                 :            :         }
     126                 :            : 
     127         [ -  + ]:          4 :         assert_se(sigprocmask(0, NULL, &ss) >= 0);
     128         [ -  + ]:          4 :         assert_se(sigismember(&ss, SIGUSR1) == 0);
     129         [ -  + ]:          4 :         assert_se(sigismember(&ss, SIGALRM) == 0);
     130         [ -  + ]:          4 :         assert_se(sigismember(&ss, SIGVTALRM) == 0);
     131                 :          4 : }
     132                 :            : 
     133                 :          4 : static void test_ignore_signals(void) {
     134         [ -  + ]:          4 :         assert_se(ignore_signals(SIGINT, -1) >= 0);
     135         [ -  + ]:          4 :         assert_se(kill(getpid_cached(), SIGINT) >= 0);
     136         [ -  + ]:          4 :         assert_se(ignore_signals(SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
     137         [ -  + ]:          4 :         assert_se(kill(getpid_cached(), SIGUSR1) >= 0);
     138         [ -  + ]:          4 :         assert_se(kill(getpid_cached(), SIGUSR2) >= 0);
     139         [ -  + ]:          4 :         assert_se(kill(getpid_cached(), SIGTERM) >= 0);
     140         [ -  + ]:          4 :         assert_se(kill(getpid_cached(), SIGPIPE) >= 0);
     141         [ -  + ]:          4 :         assert_se(default_signals(SIGINT, SIGUSR1, SIGUSR2, SIGTERM, SIGPIPE, -1) >= 0);
     142                 :          4 : }
     143                 :            : 
     144                 :          4 : int main(int argc, char *argv[]) {
     145                 :          4 :         test_rt_signals();
     146                 :          4 :         test_signal_from_string();
     147                 :          4 :         test_block_signals();
     148                 :          4 :         test_ignore_signals();
     149                 :            : 
     150                 :          4 :         return 0;
     151                 :            : }

Generated by: LCOV version 1.14