tests/lib/utilunix__my_system-common.c

   1 /*
   2    lib - common code for testing lib/utilinux:my_system() function
   3
   4    Copyright (C) 2013-2024
   5    Free Software Foundation, Inc.
   6
   7    Written by:
   8    Slava Zanko <slavazanko@gmail.com>, 2013
   9
  10    This file is part of the Midnight Commander.
  11
  12    The Midnight Commander is free software: you can redistribute it
  13    and/or modify it under the terms of the GNU General Public License as
  14    published by the Free Software Foundation, either version 3 of the License,
  15    or (at your option) any later version.
  16
  17    The Midnight Commander is distributed in the hope that it will be useful,
  18    but WITHOUT ANY WARRANTY; without even the implied warranty of
  19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20    GNU General Public License for more details.
  21
  22    You should have received a copy of the GNU General Public License
  23    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  24  */
  25
  26 #include <signal.h>
  27 #include <unistd.h>
  28
  29 #include "lib/vfs/vfs.h"
  30
  31 /* --------------------------------------------------------------------------------------------- */
  32
  33 /* @CapturedValue */
  34 static sigset_t *sigemptyset_set__captured;
  35 /* @ThenReturnValue */
  36 static int sigemptyset__return_value = 0;
  37
  38 #ifdef sigemptyset
  39 #undef sigemptyset
  40 #endif
  41
  42 /* @Mock */
  43 int
  44 sigemptyset (sigset_t *set)
  45 {
  46     sigemptyset_set__captured = set;
  47     return sigemptyset__return_value;
  48 }
  49
  50 /* --------------------------------------------------------------------------------------------- */
  51
  52 /* @CapturedValue */
  53 static GPtrArray *sigaction_signum__captured = NULL;
  54 /* @CapturedValue */
  55 static GPtrArray *sigaction_act__captured = NULL;
  56 /* @CapturedValue */
  57 static GPtrArray *sigaction_oldact__captured = NULL;
  58 /* @ThenReturnValue */
  59 static int sigaction__return_value = 0;
  60
  61 /* @Mock */
  62 int
  63 my_sigaction (int signum, const struct sigaction *act, struct sigaction *oldact)
  64 {
  65     int *tmp_signum;
  66     struct sigaction *tmp_act;
  67
  68     /* store signum */
  69     tmp_signum = g_new (int, 1);
  70     memcpy (tmp_signum, &signum, sizeof (*tmp_signum));
  71     if (sigaction_signum__captured != NULL)
  72         g_ptr_array_add (sigaction_signum__captured, tmp_signum);
  73
  74     /* store act */
  75     if (act != NULL)
  76     {
  77         tmp_act = g_new (struct sigaction, 1);
  78         memcpy (tmp_act, act, sizeof (*tmp_act));
  79     }
  80     else
  81         tmp_act = NULL;
  82     if (sigaction_act__captured != NULL)
  83         g_ptr_array_add (sigaction_act__captured, tmp_act);
  84
  85     /* store oldact */
  86     if (oldact != NULL)
  87     {
  88         tmp_act = g_new (struct sigaction, 1);
  89         memcpy (tmp_act, oldact, sizeof (*tmp_act));
  90     }
  91     else
  92         tmp_act = NULL;
  93     if (sigaction_oldact__captured != NULL)
  94         g_ptr_array_add (sigaction_oldact__captured, tmp_act);
  95
  96     return sigaction__return_value;
  97 }
  98
  99 static void
 100 sigaction__init (void)
 101 {
 102     sigaction_signum__captured = g_ptr_array_new_with_free_func (g_free);
 103     sigaction_act__captured = g_ptr_array_new_with_free_func (g_free);
 104     sigaction_oldact__captured = g_ptr_array_new_with_free_func (g_free);
 105 }
 106
 107 static void
 108 sigaction__deinit (void)
 109 {
 110     g_ptr_array_free (sigaction_signum__captured, TRUE);
 111     sigaction_signum__captured = NULL;
 112
 113     g_ptr_array_free (sigaction_act__captured, TRUE);
 114     sigaction_act__captured = NULL;
 115
 116     g_ptr_array_free (sigaction_oldact__captured, TRUE);
 117     sigaction_oldact__captured = NULL;
 118 }
 119
 120 /* --------------------------------------------------------------------------------------------- */
 121
 122 /* @CapturedValue */
 123 static GPtrArray *signal_signum__captured;
 124 /* @CapturedValue */
 125 static GPtrArray *signal_handler__captured;
 126 /* @ThenReturnValue */
 127 static sighandler_t signal__return_value = NULL;
 128
 129 /* @Mock */
 130 sighandler_t
 131 my_signal (int signum, sighandler_t handler)
 132 {
 133     int *tmp_signum;
 134     sighandler_t *tmp_handler;
 135
 136     /* store signum */
 137     tmp_signum = g_new (int, 1);
 138     memcpy (tmp_signum, &signum, sizeof (*tmp_signum));
 139     g_ptr_array_add (signal_signum__captured, tmp_signum);
 140
 141     /* store handler */
 142     if (handler != SIG_DFL)
 143     {
 144         tmp_handler = g_new (sighandler_t, 1);
 145         memcpy (tmp_handler, handler, sizeof (*tmp_handler));
 146     }
 147     else
 148         tmp_handler = (void *) SIG_DFL;
 149     g_ptr_array_add (signal_handler__captured, tmp_handler);
 150
 151     return signal__return_value;
 152 }
 153
 154 static void
 155 signal__init (void)
 156 {
 157     signal_signum__captured = g_ptr_array_new_with_free_func (g_free);
 158     signal_handler__captured = g_ptr_array_new_with_free_func (g_free);
 159 }
 160
 161 static void
 162 signal__deinit (void)
 163 {
 164     g_ptr_array_free (signal_signum__captured, TRUE);
 165     signal_signum__captured = NULL;
 166
 167     g_ptr_array_free (signal_handler__captured, TRUE);
 168     signal_handler__captured = NULL;
 169 }
 170
 171 /* --------------------------------------------------------------------------------------------- */
 172
 173 /* @ThenReturnValue */
 174 static pid_t fork__return_value;
 175
 176 /* @Mock */
 177 pid_t
 178 my_fork (void)
 179 {
 180     return fork__return_value;
 181 }
 182
 183 /* --------------------------------------------------------------------------------------------- */
 184 /* @CapturedValue */
 185 static int my_exit__status__captured;
 186
 187 /* @Mock */
 188 void
 189 my_exit (int status)
 190 {
 191     my_exit__status__captured = status;
 192 }
 193
 194 /* --------------------------------------------------------------------------------------------- */
 195
 196 /* @CapturedValue */
 197 static char *execvp__file__captured = NULL;
 198 /* @CapturedValue */
 199 static GPtrArray *execvp__args__captured;
 200 /* @ThenReturnValue */
 201 static int execvp__return_value = 0;
 202
 203 /* @Mock */
 204 int
 205 my_execvp (const char *file, char *const argv[])
 206 {
 207     char **one_arg;
 208     execvp__file__captured = g_strdup (file);
 209
 210     for (one_arg = (char **) argv; *one_arg != NULL; one_arg++)
 211         g_ptr_array_add (execvp__args__captured, g_strdup (*one_arg));
 212
 213     return execvp__return_value;
 214 }
 215
 216 static void
 217 execvp__init (void)
 218 {
 219     execvp__args__captured = g_ptr_array_new_with_free_func (g_free);
 220 }
 221
 222 static void
 223 execvp__deinit (void)
 224 {
 225     g_ptr_array_free (execvp__args__captured, TRUE);
 226     execvp__args__captured = NULL;
 227     MC_PTR_FREE (execvp__file__captured);
 228 }
 229
 230 /* --------------------------------------------------------------------------------------------- */
 231
 232 #define VERIFY_SIGACTION__ACT_IGNORED(_pntr) { \
 233     struct sigaction *_act = (struct sigaction *) _pntr; \
 234     mctest_assert_ptr_eq (_act->sa_handler, SIG_IGN); \
 235     ck_assert_int_eq (_act->sa_flags, 0); \
 236 }
 237
 238 #define VERIFY_SIGACTION__IS_RESTORED(oldact_idx, act_idx) { \
 239     struct sigaction *_oldact = (struct sigaction *) g_ptr_array_index(sigaction_oldact__captured, oldact_idx); \
 240     struct sigaction *_act = (struct sigaction *) g_ptr_array_index(sigaction_act__captured, act_idx); \
 241     ck_assert_msg (memcmp(_oldact, _act, sizeof(struct sigaction)) == 0, \
 242         "sigaction(): oldact[%d] should be equals to act[%d]", oldact_idx, act_idx); \
 243 }
 244
 245 /* @Verify */
 246 #define VERIFY_SIGACTION_CALLS() { \
 247     ck_assert_int_eq (sigaction_signum__captured->len, 6); \
 248 \
 249     ck_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 0)), SIGINT); \
 250     ck_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 1)), SIGQUIT); \
 251     ck_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 2)), SIGTSTP); \
 252     ck_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 3)), SIGINT); \
 253     ck_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 4)), SIGQUIT); \
 254     ck_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 5)), SIGTSTP); \
 255 \
 256     VERIFY_SIGACTION__ACT_IGNORED(g_ptr_array_index(sigaction_act__captured, 0)); \
 257     VERIFY_SIGACTION__ACT_IGNORED(g_ptr_array_index(sigaction_act__captured, 1)); \
 258     { \
 259         struct sigaction *_act  = g_ptr_array_index(sigaction_act__captured, 2); \
 260         ck_assert_msg (memcmp (_act, &startup_handler, sizeof(struct sigaction)) == 0, \
 261             "The 'act' in third call to sigaction() should be equals to startup_handler"); \
 262     } \
 263 \
 264     VERIFY_SIGACTION__IS_RESTORED (0, 3); \
 265     VERIFY_SIGACTION__IS_RESTORED (1, 4); \
 266     VERIFY_SIGACTION__IS_RESTORED (2, 5); \
 267 \
 268     ck_assert_msg (g_ptr_array_index(sigaction_oldact__captured, 3) == NULL, \
 269         "oldact in fourth call to sigaction() should be NULL"); \
 270     ck_assert_msg (g_ptr_array_index(sigaction_oldact__captured, 4) == NULL, \
 271         "oldact in fifth call to sigaction() should be NULL"); \
 272     ck_assert_msg (g_ptr_array_index(sigaction_oldact__captured, 5) == NULL, \
 273         "oldact in sixth call to sigaction() should be NULL"); \
 274 }
 275
 276 /* --------------------------------------------------------------------------------------------- */
 277
 278 #define VERIFY_SIGNAL_HANDLER_IS_SIG_DFL(_idx) { \
 279     sighandler_t *tmp_handler = (sighandler_t *) g_ptr_array_index(signal_handler__captured, _idx);\
 280     mctest_assert_ptr_eq (tmp_handler, (sighandler_t *) SIG_DFL); \
 281 }
 282
 283 /* @Verify */
 284 #define VERIFY_SIGNAL_CALLS() { \
 285     ck_assert_int_eq (signal_signum__captured->len, 4); \
 286     ck_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 0)), SIGINT); \
 287     ck_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 1)), SIGQUIT); \
 288     ck_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 2)), SIGTSTP); \
 289     ck_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 3)), SIGCHLD); \
 290     \
 291     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (0); \
 292     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (1); \
 293     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (2); \
 294     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (3); \
 295 }
 296
 297 /* --------------------------------------------------------------------------------------------- */
 298
 299 /* @Before */
 300 static void
 301 setup (void)
 302 {
 303     signal__return_value = NULL;
 304
 305     sigaction__init ();
 306     signal__init ();
 307     execvp__init ();
 308 }
 309
 310 /* --------------------------------------------------------------------------------------------- */
 311
 312 /* @After */
 313 static void
 314 teardown (void)
 315 {
 316     execvp__deinit ();
 317     signal__deinit ();
 318     sigaction__deinit ();
 319 }
 320
 321 /* --------------------------------------------------------------------------------------------- */