/* Test of create_pipe_bidi/wait_subprocess.
- Copyright (C) 2009 Free Software Foundation, Inc.
+ Copyright (C) 2009, 2010 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
#include "wait-process.h"
#include <errno.h>
-#include <fcntl.h>
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
+#include <unistd.h>
/* Depending on arguments, this test intentionally closes stderr or
- starts life with stderr closed. So, the error messages might not
- always print, but at least the exit status will be reliable. */
-#define ASSERT(expr) \
- do \
- { \
- if (!(expr)) \
- { \
- fprintf (stderr, "%s:%d: assertion failed\n", __FILE__, __LINE__); \
- fflush (stderr); \
- abort (); \
- } \
- } \
- while (0)
+ starts life with stderr closed. So, we arrange to have fd 10
+ (outside the range of interesting fd's during the test) set up to
+ duplicate the original stderr. */
+
+#define BACKUP_STDERR_FILENO 10
+#define ASSERT_STREAM myerr
+#include "macros.h"
+
+static FILE *myerr;
/* Code executed by the child process. argv[1] = "child". */
static int
child_main (int argc, char *argv[])
{
- char buffer[1];
- int i;
+ char buffer[2] = { 's', 't' };
int fd;
+ int ret;
ASSERT (argc == 3);
fd 2 should be closed iff the argument is 1. Check that no other file
descriptors leaked. */
- ASSERT (read (STDIN_FILENO, buffer, 1) == 1);
+ ASSERT (read (STDIN_FILENO, buffer, 2) == 1);
buffer[0]++;
ASSERT (write (STDOUT_FILENO, buffer, 1) == 1);
errno = 0;
-#ifdef F_GETFL
- /* Try to keep stderr open for better diagnostics. */
- i = fcntl (STDERR_FILENO, F_GETFL);
-#else
- /* But allow compilation on mingw. You might need to disable this code for
- debugging failures. */
- i = close (STDERR_FILENO);
-#endif
+ ret = dup2 (STDERR_FILENO, STDERR_FILENO);
switch (atoi (argv[2]))
{
case 0:
- /* Expect fd 2 was open. */
- ASSERT (i >= 0);
+ /* Expect fd 2 is open. */
+ ASSERT (ret == STDERR_FILENO);
break;
case 1:
- /* Expect fd 2 was closed. */
- ASSERT (i < 0);
+ /* Expect fd 2 is closed. */
+ ASSERT (ret == -1);
ASSERT (errno == EBADF);
break;
default:
/* Push child's input. */
ASSERT (write (fd[1], buffer, 1) == 1);
+ ASSERT (close (fd[1]) == 0);
/* Get child's output. */
ASSERT (read (fd[0], buffer, 2) == 1);
/* Wait for child. */
ASSERT (wait_subprocess (pid, argv0, true, false, true, true, NULL) == 0);
ASSERT (close (fd[0]) == 0);
- ASSERT (close (fd[1]) == 0);
/* Check the result. */
ASSERT (buffer[0] == 'b');
int
main (int argc, char *argv[])
{
- ASSERT (argc >= 2);
+ if (argc < 2)
+ {
+ fprintf (stderr, "%s: need arguments\n", argv[0]);
+ return 2;
+ }
if (strcmp (argv[1], "child") == 0)
- return child_main (argc, argv);
- else
- return parent_main (argc, argv);
+ {
+ /* fd 2 might be closed, but fd BACKUP_STDERR_FILENO is the original
+ stderr. */
+ myerr = fdopen (BACKUP_STDERR_FILENO, "w");
+ if (!myerr)
+ return 2;
+ return child_main (argc, argv);
+ }
+ /* We might close fd 2 later, so save it in fd 10. */
+ if (dup2 (STDERR_FILENO, BACKUP_STDERR_FILENO) != BACKUP_STDERR_FILENO
+ || (myerr = fdopen (BACKUP_STDERR_FILENO, "w")) == NULL)
+ return 2;
+ return parent_main (argc, argv);
}