OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [libiberty/] [testsuite/] [test-pexecute.c] - Blame information for rev 816

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 227 jeremybenn
/* Pexecute test program,
2
   Copyright (C) 2005 Free Software Foundation, Inc.
3
   Written by Ian Lance Taylor <ian@airs.com>.
4
 
5
   This file is part of GNU libiberty.
6
 
7
   This program is free software; you can redistribute it and/or modify
8
   it under the terms of the GNU General Public License as published by
9
   the Free Software Foundation; either version 2 of the License, or
10
   (at your option) any later version.
11
 
12
   This program is distributed in the hope that it will be useful,
13
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
   GNU General Public License for more details.
16
 
17
   You should have received a copy of the GNU General Public License
18
   along with this program; if not, write to the Free Software
19
   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
20
*/
21
 
22
#ifdef HAVE_CONFIG_H
23
#include "config.h"
24
#endif
25
#include "ansidecl.h"
26
#include "libiberty.h"
27
#include <stdio.h>
28
#include <signal.h>
29
#include <errno.h>
30
#ifdef HAVE_STRING_H
31
#include <string.h>
32
#endif
33
#include <sys/types.h>
34
#ifdef HAVE_STDLIB_H
35
#include <stdlib.h>
36
#endif
37
#ifdef HAVE_UNISTD_H
38
#include <unistd.h>
39
#endif
40
#ifdef HAVE_SYS_WAIT_H
41
#include <sys/wait.h>
42
#endif
43
#ifdef HAVE_SYS_TIME_H
44
#include <sys/time.h>
45
#endif
46
#ifdef HAVE_SYS_RESOURCE_H
47
#include <sys/resource.h>
48
#endif
49
 
50
#ifndef WIFSIGNALED
51
#define WIFSIGNALED(S) (((S) & 0xff) != 0 && ((S) & 0xff) != 0x7f)
52
#endif
53
#ifndef WTERMSIG
54
#define WTERMSIG(S) ((S) & 0x7f)
55
#endif
56
#ifndef WIFEXITED
57
#define WIFEXITED(S) (((S) & 0xff) == 0)
58
#endif
59
#ifndef WEXITSTATUS
60
#define WEXITSTATUS(S) (((S) & 0xff00) >> 8)
61
#endif
62
#ifndef WSTOPSIG
63
#define WSTOPSIG WEXITSTATUS
64
#endif
65
#ifndef WCOREDUMP
66
#define WCOREDUMP(S) ((S) & WCOREFLG)
67
#endif
68
#ifndef WCOREFLG
69
#define WCOREFLG 0200
70
#endif
71
 
72
#ifndef EXIT_SUCCESS
73
#define EXIT_SUCCESS 0
74
#endif
75
 
76
#ifndef EXIT_FAILURE
77
#define EXIT_FAILURE 1
78
#endif
79
 
80
/* When this program is run with no arguments, it runs some tests of
81
   the libiberty pexecute functions.  As a test program, it simply
82
   invokes itself with various arguments.
83
 
84
   argv[1]:
85
     *empty string*      Run tests, exit with success status
86
     exit                Exit success
87
     error               Exit error
88
     abort               Abort
89
     echo                Echo remaining arguments, exit success
90
     echoerr             Echo next arg to stdout, next to stderr, repeat
91
     copy                Copy stdin to stdout
92
     write               Write stdin to file named in next argument
93
*/
94
 
95
static void fatal_error (int, const char *, int) ATTRIBUTE_NORETURN;
96
static void error (int, const char *);
97
static void check_line (int, FILE *, const char *);
98
static void do_cmd (int, char **) ATTRIBUTE_NORETURN;
99
 
100
/* The number of errors we have seen.  */
101
 
102
static int error_count;
103
 
104
/* Print a fatal error and exit.  LINE is the line number where we
105
   detected the error, ERRMSG is the error message to print, and ERR
106
   is 0 or an errno value to print.  */
107
 
108
static void
109
fatal_error (int line, const char *errmsg, int err)
110
{
111
  fprintf (stderr, "test-pexecute:%d: %s", line, errmsg);
112
  if (errno != 0)
113
    fprintf (stderr, ": %s", xstrerror (err));
114
  fprintf (stderr, "\n");
115
  exit (EXIT_FAILURE);
116
}
117
 
118
#define FATAL_ERROR(ERRMSG, ERR) fatal_error (__LINE__, ERRMSG, ERR)
119
 
120
/* Print an error message and bump the error count.  LINE is the line
121
   number where we detected the error, ERRMSG is the error to
122
   print.  */
123
 
124
static void
125
error (int line, const char *errmsg)
126
{
127
  fprintf (stderr, "test-pexecute:%d: %s\n", line, errmsg);
128
  ++error_count;
129
}
130
 
131
#define ERROR(ERRMSG) error (__LINE__, ERRMSG)
132
 
133
/* Check a line in a file.  */
134
 
135
static void
136
check_line (int line, FILE *e, const char *str)
137
{
138
  const char *p;
139
  int c;
140
  char buf[1000];
141
 
142
  p = str;
143
  while (1)
144
    {
145
      c = getc (e);
146
 
147
      if (*p == '\0')
148
        {
149
          if (c != '\n')
150
            {
151
              snprintf (buf, sizeof buf, "got '%c' when expecting newline", c);
152
              fatal_error (line, buf, 0);
153
            }
154
          c = getc (e);
155
          if (c != EOF)
156
            {
157
              snprintf (buf, sizeof buf, "got '%c' when expecting EOF", c);
158
              fatal_error (line, buf, 0);
159
            }
160
          return;
161
        }
162
 
163
      if (c != *p)
164
        {
165
          snprintf (buf, sizeof buf, "expected '%c', got '%c'", *p, c);
166
          fatal_error (line, buf, 0);
167
        }
168
 
169
      ++p;
170
    }
171
}
172
 
173
#define CHECK_LINE(E, STR) check_line (__LINE__, E, STR)
174
 
175
/* Main function for the pexecute tester.  Run the tests.  */
176
 
177
int
178
main (int argc, char **argv)
179
{
180
  int trace;
181
  struct pex_obj *test_pex_tmp;
182
  int test_pex_status;
183
  FILE *test_pex_file;
184
  struct pex_obj *pex1;
185
  char *subargv[10];
186
  int status;
187
  FILE *e;
188
  int statuses[10];
189
 
190
  trace = 0;
191
  if (argc > 1 && strcmp (argv[1], "-t") == 0)
192
    {
193
      trace = 1;
194
      --argc;
195
      ++argv;
196
    }
197
 
198
  if (argc > 1)
199
    do_cmd (argc, argv);
200
 
201
#define TEST_PEX_INIT(FLAGS, TEMPBASE)                                  \
202
  (((test_pex_tmp = pex_init (FLAGS, "test-pexecute", TEMPBASE))        \
203
    != NULL)                                                            \
204
   ? test_pex_tmp                                                       \
205
   : (FATAL_ERROR ("pex_init failed", 0), NULL))
206
 
207
#define TEST_PEX_RUN(PEXOBJ, FLAGS, EXECUTABLE, ARGV, OUTNAME, ERRNAME) \
208
  do                                                                    \
209
    {                                                                   \
210
      int err;                                                          \
211
      const char *pex_run_err;                                          \
212
      if (trace)                                                        \
213
        fprintf (stderr, "Line %d: running %s %s\n",                    \
214
                 __LINE__, EXECUTABLE, ARGV[0]);                 \
215
      pex_run_err = pex_run (PEXOBJ, FLAGS, EXECUTABLE, ARGV, OUTNAME,  \
216
                             ERRNAME, &err);                            \
217
      if (pex_run_err != NULL)                                          \
218
        FATAL_ERROR (pex_run_err, err);                                 \
219
    }                                                                   \
220
  while (0)
221
 
222
#define TEST_PEX_GET_STATUS_1(PEXOBJ)                                   \
223
  (pex_get_status (PEXOBJ, 1, &test_pex_status)                         \
224
   ? test_pex_status                                                    \
225
   : (FATAL_ERROR ("pex_get_status failed", errno), 1))
226
 
227
#define TEST_PEX_GET_STATUS(PEXOBJ, COUNT, VECTOR)                      \
228
  do                                                                    \
229
    {                                                                   \
230
      if (!pex_get_status (PEXOBJ, COUNT, VECTOR))                      \
231
        FATAL_ERROR ("pex_get_status failed", errno);                   \
232
    }                                                                   \
233
  while (0)
234
 
235
#define TEST_PEX_READ_OUTPUT(PEXOBJ)                                    \
236
  ((test_pex_file = pex_read_output (PEXOBJ, 0)) != NULL         \
237
   ? test_pex_file                                                      \
238
   : (FATAL_ERROR ("pex_read_output failed", errno), NULL))
239
 
240
  remove ("temp.x");
241
  remove ("temp.y");
242
 
243
  memset (subargv, 0, sizeof subargv);
244
 
245
  subargv[0] = "./test-pexecute";
246
 
247
  pex1 = TEST_PEX_INIT (PEX_USE_PIPES, NULL);
248
  subargv[1] = "exit";
249
  subargv[2] = NULL;
250
  TEST_PEX_RUN (pex1, PEX_LAST, "./test-pexecute", subargv, NULL, NULL);
251
  status = TEST_PEX_GET_STATUS_1 (pex1);
252
  if (!WIFEXITED (status) || WEXITSTATUS (status) != EXIT_SUCCESS)
253
    ERROR ("exit failed");
254
  pex_free (pex1);
255
 
256
  pex1 = TEST_PEX_INIT (PEX_USE_PIPES, NULL);
257
  subargv[1] = "error";
258
  subargv[2] = NULL;
259
  TEST_PEX_RUN (pex1, PEX_LAST, "./test-pexecute", subargv, NULL, NULL);
260
  status = TEST_PEX_GET_STATUS_1 (pex1);
261
  if (!WIFEXITED (status) || WEXITSTATUS (status) != EXIT_FAILURE)
262
    ERROR ("error test failed");
263
  pex_free (pex1);
264
 
265
  /* We redirect stderr to a file to avoid an error message which is
266
     printed on mingw32 when the child calls abort.  */
267
  pex1 = TEST_PEX_INIT (PEX_USE_PIPES, NULL);
268
  subargv[1] = "abort";
269
  subargv[2] = NULL;
270
  TEST_PEX_RUN (pex1, PEX_LAST, "./test-pexecute", subargv, NULL, "temp.z");
271
  status = TEST_PEX_GET_STATUS_1 (pex1);
272
  if (!WIFSIGNALED (status) || WTERMSIG (status) != SIGABRT)
273
    ERROR ("abort failed");
274
  pex_free (pex1);
275
  remove ("temp.z");
276
 
277
  pex1 = TEST_PEX_INIT (PEX_USE_PIPES, "temp");
278
  subargv[1] = "echo";
279
  subargv[2] = "foo";
280
  subargv[3] = NULL;
281
  TEST_PEX_RUN (pex1, 0, "./test-pexecute", subargv, NULL, NULL);
282
  e = TEST_PEX_READ_OUTPUT (pex1);
283
  CHECK_LINE (e, "foo");
284
  if (TEST_PEX_GET_STATUS_1 (pex1) != 0)
285
    ERROR ("echo exit status failed");
286
  pex_free (pex1);
287
 
288
  pex1 = TEST_PEX_INIT (PEX_USE_PIPES, "temp");
289
  subargv[1] = "echo";
290
  subargv[2] = "bar";
291
  subargv[3] = NULL;
292
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".x", NULL);
293
  subargv[1] = "copy";
294
  subargv[2] = NULL;
295
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".y", NULL);
296
  e = TEST_PEX_READ_OUTPUT (pex1);
297
  CHECK_LINE (e, "bar");
298
  TEST_PEX_GET_STATUS (pex1, 2, statuses);
299
  if (!WIFEXITED (statuses[0]) || WEXITSTATUS (statuses[0]) != EXIT_SUCCESS
300
      || !WIFEXITED (statuses[1]) || WEXITSTATUS (statuses[1]) != EXIT_SUCCESS)
301
    ERROR ("copy exit status failed");
302
  pex_free (pex1);
303
  if (fopen ("temp.x", "r") != NULL || fopen ("temp.y", "r") != NULL)
304
    ERROR ("temporary files exist");
305
 
306
  pex1 = TEST_PEX_INIT (0, "temp");
307
  subargv[1] = "echo";
308
  subargv[2] = "bar";
309
  subargv[3] = NULL;
310
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".x", NULL);
311
  subargv[1] = "copy";
312
  subargv[2] = NULL;
313
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".y", NULL);
314
  e = TEST_PEX_READ_OUTPUT (pex1);
315
  CHECK_LINE (e, "bar");
316
  TEST_PEX_GET_STATUS (pex1, 2, statuses);
317
  if (!WIFEXITED (statuses[0]) || WEXITSTATUS (statuses[0]) != EXIT_SUCCESS
318
      || !WIFEXITED (statuses[1]) || WEXITSTATUS (statuses[1]) != EXIT_SUCCESS)
319
    ERROR ("copy exit status failed");
320
  pex_free (pex1);
321
  if (fopen ("temp.x", "r") != NULL || fopen ("temp.y", "r") != NULL)
322
    ERROR ("temporary files exist");
323
 
324
  pex1 = TEST_PEX_INIT (PEX_SAVE_TEMPS, "temp");
325
  subargv[1] = "echo";
326
  subargv[2] = "quux";
327
  subargv[3] = NULL;
328
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".x", NULL);
329
  subargv[1] = "copy";
330
  subargv[2] = NULL;
331
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".y", NULL);
332
  e = TEST_PEX_READ_OUTPUT (pex1);
333
  CHECK_LINE (e, "quux");
334
  TEST_PEX_GET_STATUS (pex1, 2, statuses);
335
  if (!WIFEXITED (statuses[0]) || WEXITSTATUS (statuses[0]) != EXIT_SUCCESS
336
      || !WIFEXITED (statuses[1]) || WEXITSTATUS (statuses[1]) != EXIT_SUCCESS)
337
    ERROR ("copy temp exit status failed");
338
  e = fopen ("temp.x", "r");
339
  if (e == NULL)
340
    FATAL_ERROR ("fopen temp.x failed in copy temp", errno);
341
  CHECK_LINE (e, "quux");
342
  fclose (e);
343
  e = fopen ("temp.y", "r");
344
  if (e == NULL)
345
    FATAL_ERROR ("fopen temp.y failed in copy temp", errno);
346
  CHECK_LINE (e, "quux");
347
  fclose (e);
348
  pex_free (pex1);
349
  remove ("temp.x");
350
  remove ("temp.y");
351
 
352
  pex1 = TEST_PEX_INIT (PEX_USE_PIPES, "temp");
353
  subargv[1] = "echoerr";
354
  subargv[2] = "one";
355
  subargv[3] = "two";
356
  subargv[4] = NULL;
357
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".x", "temp2.x");
358
  subargv[1] = "write";
359
  subargv[2] = "temp2.y";
360
  subargv[3] = NULL;
361
  TEST_PEX_RUN (pex1, PEX_SUFFIX, "./test-pexecute", subargv, ".y", NULL);
362
  TEST_PEX_GET_STATUS (pex1, 2, statuses);
363
  if (!WIFEXITED (statuses[0]) || WEXITSTATUS (statuses[0]) != EXIT_SUCCESS
364
      || !WIFEXITED (statuses[1]) || WEXITSTATUS (statuses[1]) != EXIT_SUCCESS)
365
    ERROR ("echoerr exit status failed");
366
  pex_free (pex1);
367
  if (fopen ("temp.x", "r") != NULL || fopen ("temp.y", "r") != NULL)
368
    ERROR ("temporary files exist");
369
  e = fopen ("temp2.x", "r");
370
  if (e == NULL)
371
    FATAL_ERROR ("fopen temp2.x failed in echoerr", errno);
372
  CHECK_LINE (e, "two");
373
  fclose (e);
374
  e = fopen ("temp2.y", "r");
375
  if (e == NULL)
376
    FATAL_ERROR ("fopen temp2.y failed in echoerr", errno);
377
  CHECK_LINE (e, "one");
378
  fclose (e);
379
  remove ("temp2.x");
380
  remove ("temp2.y");
381
 
382
  /* Test the old pexecute interface.  */
383
  {
384
    int pid1, pid2;
385
    char *errmsg_fmt;
386
    char *errmsg_arg;
387
    char errbuf1[1000];
388
    char errbuf2[1000];
389
 
390
    subargv[1] = "echo";
391
    subargv[2] = "oldpexecute";
392
    subargv[3] = NULL;
393
    pid1 = pexecute ("./test-pexecute", subargv, "test-pexecute", "temp",
394
                     &errmsg_fmt, &errmsg_arg, PEXECUTE_FIRST);
395
    if (pid1 < 0)
396
      {
397
        snprintf (errbuf1, sizeof errbuf1, errmsg_fmt, errmsg_arg);
398
        snprintf (errbuf2, sizeof errbuf2, "pexecute 1 failed: %s", errbuf1);
399
        FATAL_ERROR (errbuf2, 0);
400
      }
401
 
402
    subargv[1] = "write";
403
    subargv[2] = "temp.y";
404
    subargv[3] = NULL;
405
    pid2 = pexecute ("./test-pexecute", subargv, "test-pexecute", "temp",
406
                     &errmsg_fmt, &errmsg_arg, PEXECUTE_LAST);
407
    if (pid2 < 0)
408
      {
409
        snprintf (errbuf1, sizeof errbuf1, errmsg_fmt, errmsg_arg);
410
        snprintf (errbuf2, sizeof errbuf2, "pexecute 2 failed: %s", errbuf1);
411
        FATAL_ERROR (errbuf2, 0);
412
      }
413
 
414
    if (pwait (pid1, &status, 0) < 0)
415
      FATAL_ERROR ("write pwait 1 failed", errno);
416
    if (!WIFEXITED (status) || WEXITSTATUS (status) != EXIT_SUCCESS)
417
      ERROR ("write exit status 1 failed");
418
 
419
    if (pwait (pid2, &status, 0) < 0)
420
      FATAL_ERROR ("write pwait 1 failed", errno);
421
    if (!WIFEXITED (status) || WEXITSTATUS (status) != EXIT_SUCCESS)
422
      ERROR ("write exit status 2 failed");
423
 
424
    e = fopen ("temp.y", "r");
425
    if (e == NULL)
426
      FATAL_ERROR ("fopen temp.y failed in copy temp", errno);
427
    CHECK_LINE (e, "oldpexecute");
428
    fclose (e);
429
 
430
    remove ("temp.y");
431
  }
432
 
433
  if (trace)
434
    fprintf (stderr, "Exiting with status %d\n", error_count);
435
 
436
  return error_count;
437
}
438
 
439
/* Execute one of the special testing commands.  */
440
 
441
static void
442
do_cmd (int argc, char **argv)
443
{
444
  const char *s;
445
 
446
  /* Try to prevent generating a core dump.  */
447
#ifdef RLIMIT_CORE
448
 {
449
   struct rlimit r;
450
 
451
   r.rlim_cur = 0;
452
   r.rlim_max = 0;
453
   setrlimit (RLIMIT_CORE, &r);
454
 }
455
#endif
456
 
457
  s = argv[1];
458
  if (strcmp (s, "exit") == 0)
459
    exit (EXIT_SUCCESS);
460
  else if (strcmp (s, "echo") == 0)
461
    {
462
      int i;
463
 
464
      for (i = 2; i < argc; ++i)
465
        {
466
          if (i > 2)
467
            putchar (' ');
468
          fputs (argv[i], stdout);
469
        }
470
      putchar ('\n');
471
      exit (EXIT_SUCCESS);
472
    }
473
  else if (strcmp (s, "echoerr") == 0)
474
    {
475
      int i;
476
 
477
      for (i = 2; i < argc; ++i)
478
        {
479
          if (i > 3)
480
            putc (' ', (i & 1) == 0 ? stdout : stderr);
481
          fputs (argv[i], (i & 1) == 0 ? stdout : stderr);
482
        }
483
      putc ('\n', stdout);
484
      putc ('\n', stderr);
485
      exit (EXIT_SUCCESS);
486
    }
487
  else if (strcmp (s, "error") == 0)
488
    exit (EXIT_FAILURE);
489
  else if (strcmp (s, "abort") == 0)
490
    abort ();
491
  else if (strcmp (s, "copy") == 0)
492
    {
493
      int c;
494
 
495
      while ((c = getchar ()) != EOF)
496
        putchar (c);
497
      exit (EXIT_SUCCESS);
498
    }
499
  else if (strcmp (s, "write") == 0)
500
    {
501
      FILE *e;
502
      int c;
503
 
504
      e = fopen (argv[2], "w");
505
      if (e == NULL)
506
        FATAL_ERROR ("fopen for write failed", errno);
507
      while ((c = getchar ()) != EOF)
508
        putc (c, e);
509
      if (fclose (e) != 0)
510
        FATAL_ERROR ("fclose for write failed", errno);
511
      exit (EXIT_SUCCESS);
512
    }
513
  else
514
    {
515
      char buf[1000];
516
 
517
      snprintf (buf, sizeof buf, "unrecognized command %s", argv[1]);
518
      FATAL_ERROR (buf, 0);
519
    }
520
 
521
  exit (EXIT_FAILURE);
522
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.