src/test/test-signal-util.c

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