tests/lib/utilunix__my_system-common.c

   1 /*
   2    lib - common code for testing lib/utilinux:my_system() function
   3
   4    Copyright (C) 2013
   5    The 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 /* @Mock */
  39 int
  40 sigemptyset (sigset_t * set)
  41 {
  42     sigemptyset_set__captured = set;
  43     return sigemptyset__return_value;
  44 }
  45
  46 /* --------------------------------------------------------------------------------------------- */
  47
  48 /* @CapturedValue */
  49 static GPtrArray *sigaction_signum__captured = NULL;
  50 /* @CapturedValue */
  51 static GPtrArray *sigaction_act__captured = NULL;
  52 /* @CapturedValue */
  53 static GPtrArray *sigaction_oldact__captured = NULL;
  54 /* @ThenReturnValue */
  55 static int sigaction__return_value = 0;
  56
  57 /* @Mock */
  58 int
  59 sigaction (int signum, const struct sigaction *act, struct sigaction *oldact)
  60 {
  61     int *tmp_signum;
  62     struct sigaction *tmp_act;
  63
  64     /* store signum */
  65     tmp_signum = g_new (int, 1);
  66     memcpy (tmp_signum, &signum, sizeof (int));
  67     if (sigaction_signum__captured != NULL)
  68         g_ptr_array_add (sigaction_signum__captured, tmp_signum);
  69
  70     /* store act */
  71     if (act != NULL)
  72     {
  73         tmp_act = g_new (struct sigaction, 1);
  74         memcpy (tmp_act, act, sizeof (struct sigaction));
  75     }
  76     else
  77         tmp_act = NULL;
  78     if (sigaction_act__captured != NULL)
  79         g_ptr_array_add (sigaction_act__captured, tmp_act);
  80
  81     /* store oldact */
  82     if (oldact != NULL)
  83     {
  84         tmp_act = g_new (struct sigaction, 1);
  85         memcpy (tmp_act, oldact, sizeof (struct sigaction));
  86     }
  87     else
  88         tmp_act = NULL;
  89     if (sigaction_oldact__captured != NULL)
  90         g_ptr_array_add (sigaction_oldact__captured, tmp_act);
  91
  92     return sigaction__return_value;
  93 }
  94
  95 static void
  96 sigaction__init (void)
  97 {
  98     sigaction_signum__captured = g_ptr_array_new ();
  99     sigaction_act__captured = g_ptr_array_new ();
 100     sigaction_oldact__captured = g_ptr_array_new ();
 101 }
 102
 103 static void
 104 sigaction__deinit (void)
 105 {
 106     g_ptr_array_foreach (sigaction_signum__captured, (GFunc) g_free, NULL);
 107     g_ptr_array_free (sigaction_signum__captured, TRUE);
 108
 109     g_ptr_array_foreach (sigaction_act__captured, (GFunc) g_free, NULL);
 110     g_ptr_array_free (sigaction_act__captured, TRUE);
 111
 112     g_ptr_array_foreach (sigaction_oldact__captured, (GFunc) g_free, NULL);
 113     g_ptr_array_free (sigaction_oldact__captured, TRUE);
 114 }
 115
 116 /* --------------------------------------------------------------------------------------------- */
 117
 118 /* @CapturedValue */
 119 static GPtrArray *signal_signum__captured;
 120 /* @CapturedValue */
 121 static GPtrArray *signal_handler__captured;
 122 /* @ThenReturnValue */
 123 static sighandler_t signal__return_value = NULL;
 124
 125 /* @Mock */
 126 sighandler_t
 127 signal (int signum, sighandler_t handler)
 128 {
 129     int *tmp_signum;
 130     sighandler_t *tmp_handler;
 131
 132     /* store signum */
 133     tmp_signum = g_new (int, 1);
 134     memcpy (tmp_signum, &signum, sizeof (int));
 135     g_ptr_array_add (signal_signum__captured, tmp_signum);
 136
 137     /* store handler */
 138     if (handler != SIG_DFL)
 139     {
 140         tmp_handler = g_new (sighandler_t, 1);
 141         memcpy (tmp_handler, handler, sizeof (sighandler_t));
 142     }
 143     else
 144         tmp_handler = (void *) SIG_DFL;
 145     g_ptr_array_add (signal_handler__captured, tmp_handler);
 146
 147     return signal__return_value;
 148 }
 149
 150 static void
 151 signal__init (void)
 152 {
 153     signal_signum__captured = g_ptr_array_new ();
 154     signal_handler__captured = g_ptr_array_new ();
 155 }
 156
 157 static void
 158 signal__deinit (void)
 159 {
 160     g_ptr_array_foreach (signal_signum__captured, (GFunc) g_free, NULL);
 161     g_ptr_array_free (signal_signum__captured, TRUE);
 162
 163     g_ptr_array_foreach (signal_handler__captured, (GFunc) g_free, NULL);
 164     g_ptr_array_free (signal_handler__captured, TRUE);
 165 }
 166
 167 /* --------------------------------------------------------------------------------------------- */
 168
 169 /* @ThenReturnValue */
 170 static pid_t fork__return_value;
 171
 172 /* @Mock */
 173 pid_t
 174 fork (void)
 175 {
 176     return fork__return_value;
 177 }
 178
 179 /* --------------------------------------------------------------------------------------------- */
 180 /* @CapturedValue */
 181 static int my_exit__status__captured;
 182
 183 /* @Mock */
 184 void
 185 my_exit (int status)
 186 {
 187     my_exit__status__captured = status;
 188 }
 189
 190 /* --------------------------------------------------------------------------------------------- */
 191
 192 /* @CapturedValue */
 193 static char *execvp__file__captured = NULL;
 194 /* @CapturedValue */
 195 static GPtrArray *execvp__args__captured;
 196 /* @ThenReturnValue */
 197 static int execvp__return_value = 0;
 198
 199 /* @Mock */
 200 int
 201 execvp (const char *file, char *const argv[])
 202 {
 203     char **one_arg;
 204     execvp__file__captured = g_strdup (file);
 205
 206     for (one_arg = (char **) argv; *one_arg != NULL; one_arg++)
 207         g_ptr_array_add (execvp__args__captured, g_strdup (*one_arg));
 208
 209     return execvp__return_value;
 210 }
 211
 212 static void
 213 execvp__init (void)
 214 {
 215     execvp__args__captured = g_ptr_array_new ();
 216 }
 217
 218 static void
 219 execvp__deinit (void)
 220 {
 221     g_ptr_array_foreach (execvp__args__captured, (GFunc) g_free, NULL);
 222     g_ptr_array_free (execvp__args__captured, TRUE);
 223     g_free (execvp__file__captured);
 224 }
 225
 226 /* --------------------------------------------------------------------------------------------- */
 227
 228 #define VERIFY_SIGACTION__ACT_IGNORED(_pntr) { \
 229     struct sigaction *_act = (struct sigaction *) _pntr; \
 230     mctest_assert_ptr_eq (_act->sa_handler, SIG_IGN); \
 231     mctest_assert_int_eq (_act->sa_flags, 0); \
 232 }
 233
 234 #define VERIFY_SIGACTION__IS_RESTORED(oldact_idx, act_idx) { \
 235     struct sigaction *_oldact = (struct sigaction *) g_ptr_array_index(sigaction_oldact__captured, oldact_idx); \
 236     struct sigaction *_act = (struct sigaction *) g_ptr_array_index(sigaction_act__captured, act_idx); \
 237     fail_unless (memcmp(_oldact, _act, sizeof(struct sigaction)) == 0, \
 238         "sigaction(): oldact[%d] should be equals to act[%d]", oldact_idx, act_idx); \
 239 }
 240
 241 /* @Verify */
 242 #define VERIFY_SIGACTION_CALLS() { \
 243     mctest_assert_int_eq (sigaction_signum__captured->len, 6); \
 244 \
 245     mctest_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 0)), SIGINT); \
 246     mctest_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 1)), SIGQUIT); \
 247     mctest_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 2)), SIGTSTP); \
 248     mctest_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 3)), SIGINT); \
 249     mctest_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 4)), SIGQUIT); \
 250     mctest_assert_int_eq (*((int *) g_ptr_array_index(sigaction_signum__captured, 5)), SIGTSTP); \
 251 \
 252     VERIFY_SIGACTION__ACT_IGNORED(g_ptr_array_index(sigaction_act__captured, 0)); \
 253     VERIFY_SIGACTION__ACT_IGNORED(g_ptr_array_index(sigaction_act__captured, 1)); \
 254     { \
 255         struct sigaction *_act  = g_ptr_array_index(sigaction_act__captured, 2); \
 256         fail_unless (memcmp (_act, &startup_handler, sizeof(struct sigaction)) == 0, \
 257             "The 'act' in third call to sigaction() should be equals to startup_handler"); \
 258     } \
 259 \
 260     VERIFY_SIGACTION__IS_RESTORED (0, 3); \
 261     VERIFY_SIGACTION__IS_RESTORED (1, 4); \
 262     VERIFY_SIGACTION__IS_RESTORED (2, 5); \
 263 \
 264     fail_unless (g_ptr_array_index(sigaction_oldact__captured, 3) == NULL, \
 265         "oldact in fourth call to sigaction() should be NULL"); \
 266     fail_unless (g_ptr_array_index(sigaction_oldact__captured, 4) == NULL, \
 267         "oldact in fifth call to sigaction() should be NULL"); \
 268     fail_unless (g_ptr_array_index(sigaction_oldact__captured, 5) == NULL, \
 269         "oldact in sixth call to sigaction() should be NULL"); \
 270 }
 271
 272 /* --------------------------------------------------------------------------------------------- */
 273
 274 #define VERIFY_SIGNAL_HANDLER_IS_SIG_DFL(_idx) { \
 275     sighandler_t *tmp_handler = (sighandler_t *) g_ptr_array_index(signal_handler__captured, _idx);\
 276     mctest_assert_ptr_eq (tmp_handler, (sighandler_t *) SIG_DFL); \
 277 }
 278
 279 /* @Verify */
 280 #define VERIFY_SIGNAL_CALLS() { \
 281     mctest_assert_int_eq (signal_signum__captured->len, 4); \
 282     mctest_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 0)), SIGINT); \
 283     mctest_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 1)), SIGQUIT); \
 284     mctest_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 2)), SIGTSTP); \
 285     mctest_assert_int_eq (*((int *) g_ptr_array_index(signal_signum__captured, 3)), SIGCHLD); \
 286     \
 287     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (0); \
 288     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (1); \
 289     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (2); \
 290     VERIFY_SIGNAL_HANDLER_IS_SIG_DFL (3); \
 291 }
 292
 293 /* --------------------------------------------------------------------------------------------- */
 294
 295 /* @Before */
 296 static void
 297 setup (void)
 298 {
 299     signal__return_value = NULL;
 300
 301     sigaction__init ();
 302     signal__init ();
 303     execvp__init ();
 304 }
 305
 306 /* --------------------------------------------------------------------------------------------- */
 307
 308 /* @After */
 309 static void
 310 teardown (void)
 311 {
 312     execvp__deinit ();
 313     signal__deinit ();
 314     sigaction__deinit ();
 315 }
 316
 317 /* --------------------------------------------------------------------------------------------- */