test-skeleton.c

   1 /* Skeleton for test programs.
   2    Copyright (C) 1998, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1998.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, write to the Free
  18    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  19    02111-1307 USA.  */
  20
  21 #include <errno.h>
  22 #include <getopt.h>
  23 #include <search.h>
  24 #include <signal.h>
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #include <unistd.h>
  29 #include <sys/resource.h>
  30 #include <sys/wait.h>
  31 #include <sys/param.h>
  32
  33 /* The test function is normally called `do_test' and it is called
  34    with argc and argv as the arguments.  We nevertheless provide the
  35    possibility to overwrite this name.  */
  36 #ifndef TEST_FUNCTION
  37 # define TEST_FUNCTION do_test (argc, argv)
  38 #endif
  39
  40 #ifndef TEST_DATA_LIMIT
  41 # define TEST_DATA_LIMIT (64 << 20) /* Data limit (bytes) to run with.  */
  42 #endif
  43
  44 #define OPT_DIRECT 1000
  45 #define OPT_TESTDIR 1001
  46
  47 static struct option options[] =
  48 {
  49 #ifdef CMDLINE_OPTIONS
  50   CMDLINE_OPTIONS
  51 #endif
  52   { "direct", no_argument, NULL, OPT_DIRECT },
  53   { "test-dir", required_argument, NULL, OPT_TESTDIR },
  54   { NULL, 0, NULL, 0 }
  55 };
  56
  57 /* PID of the test itself.  */
  58 static pid_t pid;
  59
  60 /* Directory to place temporary files in.  */
  61 static const char *test_dir;
  62
  63 /* List of temporary files.  */
  64 struct temp_name_list
  65 {
  66   struct qelem q;
  67   const char *name;
  68 } *temp_name_list;
  69
  70 /* Add temporary files in list.  */
  71 static void
  72 __attribute__ ((unused))
  73 add_temp_file (const char *name)
  74 {
  75   struct temp_name_list *newp
  76     = (struct temp_name_list *) calloc (sizeof (*newp), 1);
  77   if (newp != NULL)
  78     {
  79       newp->name = name;
  80       if (temp_name_list == NULL)
  81         temp_name_list = (struct temp_name_list *) &newp->q;
  82       else
  83         insque (newp, temp_name_list);
  84     }
  85 }
  86
  87 /* Delete all temporary files.  */
  88 static void
  89 delete_temp_files (void)
  90 {
  91   while (temp_name_list != NULL)
  92     {
  93       remove (temp_name_list->name);
  94       temp_name_list = (struct temp_name_list *) temp_name_list->q.q_forw;
  95     }
  96 }
  97
  98 /* Create a temporary file.  */
  99 static int
 100 __attribute__ ((unused))
 101 create_temp_file (const char *base, char **filename)
 102 {
 103   char *fname;
 104   int fd;
 105
 106   fname = (char *) malloc (strlen (test_dir) + 1 + strlen (base)
 107                            + sizeof ("XXXXXX"));
 108   if (fname == NULL)
 109     {
 110       puts ("out of memory");
 111       return -1;
 112     }
 113   strcpy (stpcpy (stpcpy (stpcpy (fname, test_dir), "/"), base), "XXXXXX");
 114
 115   fd = mkstemp (fname);
 116   if (fd == -1)
 117     {
 118       printf ("cannot open temporary file '%s': %m\n", fname);
 119       free (fname);
 120       return -1;
 121     }
 122
 123   add_temp_file (fname);
 124   if (filename != NULL)
 125     *filename = fname;
 126
 127   return fd;
 128 }
 129
 130 /* Timeout handler.  We kill the child and exit with an error.  */
 131 static void
 132 __attribute__ ((noreturn))
 133 timeout_handler (int sig __attribute__ ((unused)))
 134 {
 135   int killed;
 136   int status;
 137
 138   /* Send signal.  */
 139   kill (pid, SIGKILL);
 140
 141   /* Wait for it to terminate.  */
 142   killed = waitpid (pid, &status, WNOHANG|WUNTRACED);
 143   if (killed != 0 && killed != pid)
 144     {
 145       perror ("Failed to killed test process");
 146       exit (1);
 147     }
 148
 149 #ifdef CLEANUP_HANDLER
 150   CLEANUP_HANDLER;
 151 #endif
 152
 153   /* If we expected this signal: good!  */
 154 #ifdef EXPECTED_SIGNAL
 155   if (EXPECTED_SIGNAL == SIGALRM)
 156     exit (0);
 157 #endif
 158
 159   if (WIFSIGNALED (status) && WTERMSIG (status) == SIGKILL)
 160     fputs ("Timed out: killed the child process\n", stderr);
 161   else if (WIFSTOPPED (status))
 162     fprintf (stderr, "Timed out: the child process was %s\n",
 163              strsignal (WSTOPSIG (status)));
 164   else if (WIFSIGNALED (status))
 165     fprintf (stderr, "Timed out: the child process got signal %s\n",
 166              strsignal (WTERMSIG (status)));
 167   else
 168     fprintf (stderr, "Timed out: killed the child process but it exited %d\n",
 169              WEXITSTATUS (status));
 170
 171   /* Exit with an error.  */
 172   exit (1);
 173 }
 174
 175 /* We provide the entry point here.  */
 176 int
 177 main (int argc, char *argv[])
 178 {
 179   int direct = 0;       /* Directly call the test function?  */
 180   int status;
 181   int opt;
 182   pid_t termpid;
 183
 184 #ifdef STDOUT_UNBUFFERED
 185   setbuf (stdout, NULL);
 186 #endif
 187
 188   while ((opt = getopt_long (argc, argv, "+", options, NULL)) != -1)
 189     switch (opt)
 190       {
 191       case '?':
 192         exit (1);
 193       case OPT_DIRECT:
 194         direct = 1;
 195         break;
 196       case OPT_TESTDIR:
 197         test_dir = optarg;
 198         break;
 199 #ifdef CMDLINE_PROCESS
 200         CMDLINE_PROCESS
 201 #endif
 202       }
 203
 204   /* Set TMPDIR to specified test directory.  */
 205   if (test_dir != NULL)
 206     {
 207       setenv ("TMPDIR", test_dir, 1);
 208
 209       if (chdir (test_dir) < 0)
 210         {
 211           perror ("chdir");
 212           exit (1);
 213         }
 214     }
 215   else
 216     {
 217       test_dir = getenv ("TMPDIR");
 218       if (test_dir == NULL || test_dir[0] == '\0')
 219         test_dir = "/tmp";
 220     }
 221
 222   /* Make sure we see all message, even those on stdout.  */
 223   setvbuf (stdout, NULL, _IONBF, 0);
 224
 225   /* make sure temporary files are deleted.  */
 226   atexit (delete_temp_files);
 227
 228   /* Correct for the possible parameters.  */
 229   argv[optind - 1] = argv[0];
 230   argv += optind - 1;
 231   argc -= optind - 1;
 232
 233   /* Call the initializing function, if one is available.  */
 234 #ifdef PREPARE
 235   PREPARE (argc, argv);
 236 #endif
 237
 238   /* If we are not expected to fork run the function immediately.  */
 239   if (direct)
 240     return TEST_FUNCTION;
 241
 242   /* Set up the test environment:
 243      - prevent core dumps
 244      - set up the timer
 245      - fork and execute the function.  */
 246
 247   pid = fork ();
 248   if (pid == 0)
 249     {
 250       /* This is the child.  */
 251 #ifdef RLIMIT_CORE
 252       /* Try to avoid dumping core.  */
 253       struct rlimit core_limit;
 254       core_limit.rlim_cur = 0;
 255       core_limit.rlim_max = 0;
 256       setrlimit (RLIMIT_CORE, &core_limit);
 257 #endif
 258
 259 #ifdef RLIMIT_DATA
 260       /* Try to avoid eating all memory if a test leaks.  */
 261       struct rlimit data_limit;
 262       if (getrlimit (RLIMIT_DATA, &data_limit) == 0)
 263         {
 264           if (TEST_DATA_LIMIT == RLIM_INFINITY)
 265             data_limit.rlim_cur = data_limit.rlim_max;
 266           else if (data_limit.rlim_cur > (rlim_t) TEST_DATA_LIMIT)
 267             data_limit.rlim_cur = MIN ((rlim_t) TEST_DATA_LIMIT,
 268                                        data_limit.rlim_max);
 269           if (setrlimit (RLIMIT_DATA, &data_limit) < 0)
 270             perror ("setrlimit: RLIMIT_DATA");
 271         }
 272       else
 273         perror ("getrlimit: RLIMIT_DATA");
 274 #endif
 275
 276       /* We put the test process in its own pgrp so that if it bogusly
 277          generates any job control signals, they won't hit the whole build.  */
 278       setpgid (0, 0);
 279
 280       /* Execute the test function and exit with the return value.   */
 281       exit (TEST_FUNCTION);
 282     }
 283   else if (pid < 0)
 284     {
 285       perror ("Cannot fork test program");
 286       exit (1);
 287     }
 288
 289   /* Set timeout.  */
 290 #ifndef TIMEOUT
 291   /* Default timeout is two seconds.  */
 292 # define TIMEOUT 2
 293 #endif
 294   signal (SIGALRM, timeout_handler);
 295   alarm (TIMEOUT);
 296
 297   /* Wait for the regular termination.  */
 298   termpid = TEMP_FAILURE_RETRY (waitpid (pid, &status, 0));
 299   if (termpid == -1)
 300     {
 301       printf ("Waiting for test program failed: %m\n");
 302       exit (1);
 303     }
 304   if (termpid != pid)
 305     {
 306       printf ("Oops, wrong test program terminated: expected %ld, got %ld\n",
 307               (long int) pid, (long int) termpid);
 308       exit (1);
 309     }
 310
 311 #ifndef EXPECTED_SIGNAL
 312   /* We don't expect any signal.  */
 313 # define EXPECTED_SIGNAL 0
 314 #endif
 315   if (WTERMSIG (status) != EXPECTED_SIGNAL)
 316     {
 317       if (EXPECTED_SIGNAL != 0)
 318         {
 319           if (WTERMSIG (status) == 0)
 320             fprintf (stderr,
 321                      "Expected signal '%s' from child, got none\n",
 322                      strsignal (EXPECTED_SIGNAL));
 323           else
 324             fprintf (stderr,
 325                      "Incorrect signal from child: got `%s', need `%s'\n",
 326                      strsignal (WTERMSIG (status)),
 327                      strsignal (EXPECTED_SIGNAL));
 328         }
 329       else
 330         fprintf (stderr, "Didn't expect signal from child: got `%s'\n",
 331                  strsignal (WTERMSIG (status)));
 332       exit (1);
 333     }
 334
 335   /* Simply exit with the return value of the test.  */
 336 #ifndef EXPECTED_STATUS
 337   return WEXITSTATUS (status);
 338 #else
 339   if (WEXITSTATUS (status) != EXPECTED_STATUS)
 340     {
 341       fprintf (stderr, "Expected status %d, got %d\n",
 342                EXPECTED_STATUS, WEXITSTATUS (status));
 343       exit (1);
 344     }
 345
 346   return 0;
 347 #endif
 348 }