path: root/stdio-common/tst-setvbuf2.c

/* Test setvbuf under various conditions.
   Copyright (C) 2025 Free Software Foundation, Inc.
   This file is part of the GNU C Library.

   The GNU C Library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
   License as published by the Free Software Foundation; either
   version 2.1 of the License, or (at your option) any later version.

   The GNU C Library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public
   License along with the GNU C Library; if not, see
   <https://www.gnu.org/licenses/>.  */

/* This file is used twice, once as the test itself (where do_test
   is defined) and once as a subprocess we spawn to test stdin et all
   (where main is defined).  INDEPENDENT_PART is defined for the
   latter.

   Note also that the purpose of this test is to test setvbuf, not the
   underlying buffering code.  */

#include <stdbool.h>
#include <stdio.h>
#include <stdio_ext.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <libio.h>
#include <termios.h>

#include <support/support.h>
#include <support/check.h>
#include <support/temp_file.h>
#include <support/xstdio.h>
#include <support/xunistd.h>
#include <support/xthread.h>
#include <support/tty.h>

/* Dear future developer: If you are reading this, you are likely
   trying to change or understand this test.  In that case, these
   debug/dump macros will be helpful.  */
#if 0
# define debug printf ("\033[3%dm%s:%d\033[0m\n", \
		       (__LINE__ % 6) + 1, __FUNCTION__, __LINE__);

static void
dumpfp (FILE *fp)
{
  char f[10], *p=f;

  if (fp->_flags & _IO_UNBUFFERED)
    *p++ = 'N';
  if (fp->_flags & _IO_LINE_BUF)
    *p++ = 'L';
  if (p == f)
    *p++ = 'B';
  *p = 0;

  printf ("FILE %p flags %s"
	  " read %p \033[%dm%+ld \033[%dm%+ld\033[0m"
	  " write %p \033[%dm%+ld \033[%dm%+ld\033[0m %ld"
	  " buf %p \033[%dm%+ld\033[0m  sz %ld pend %ld\n",
	  fp, f,

	  fp->_IO_read_base,
	  fp->_IO_read_ptr == fp->_IO_read_base ? 33 : 32,
	  fp->_IO_read_ptr - fp->_IO_read_base,
	  fp->_IO_read_end == fp->_IO_read_base ? 33 : 36,
	  fp->_IO_read_end - fp->_IO_read_base,

	  fp->_IO_write_base,
	  fp->_IO_write_ptr == fp->_IO_write_base ? 33 : 32,
	  fp->_IO_write_ptr - fp->_IO_write_base,
	  fp->_IO_write_end == fp->_IO_write_base ? 33 : 36,
	  fp->_IO_write_end - fp->_IO_write_base,
	  fp->_IO_write_end - fp->_IO_write_base,

	  fp->_IO_buf_base,
	  fp->_IO_buf_end == fp->_IO_buf_base ? 33 : 35,
	  fp->_IO_buf_end - fp->_IO_buf_base,
	  __fbufsize (fp), __fpending (fp)
	  );
}
#else
# define debug
# define dumpfp(FP)
#endif

#ifndef INDEPENDENT_PART
/* st_blksize value for that file, or BUFSIZ if out of range.  */
static int blksize = BUFSIZ;
#endif

/* Our test buffer.  */
#define TEST_BUFSIZE 42
static int bufsize = TEST_BUFSIZE < BUFSIZ ? TEST_BUFSIZE : BUFSIZ;
static char *buffer;

/* Test data, both written to that file and used as an in-memory
   stream.  */
char test_data[2 * BUFSIZ];

#define TEST_STRING "abcdef\n"

enum test_source_case
  {
    test_source_file,
    test_source_pipe,
    test_source_fifo,
    test_source_pseudo_terminal,
    test_source_dev_null,
    test_source_count,
  };

static const char *const test_source_name[test_source_count] =
  {
    "regular file",
    "pipe",
    "fifo",
    "pseudo_terminal",
    "dev_null"
  };

enum test_stream_case
  {
    test_stream_stdin,
    test_stream_stdout,
    test_stream_stderr,
    test_stream_fopen_r,
    test_stream_fdopen_r,
    test_stream_fopen_w,
    test_stream_fdopen_w,
    test_stream_count
  };

static bool test_stream_reads[test_stream_count] =
  {
    true,
    false,
    false,
    true,
    true,
    false,
    false
  };

static const char *const test_stream_name[test_stream_count] =
  {
    "stdin",
    "stdout",
    "stderr",
    "fopen (read)",
    "fdopen (read)",
    "fopen (write)",
    "fdopen (write)"
  };

enum test_config_case
  {
    test_config_none,
    test_config_unbuffered,
    test_config_line,
    test_config_fully,
    test_config_count
  };

static const char *const test_config_name[test_config_count] =
  {
    "no change",
    "unbuffered",
    "line buffered",
    "fully buffered"
  };

FILE *test_stream;

char *test_file_name = NULL;
int pty_fd;
char *test_pipe_name = NULL;
int test_pipe[2];

/* This is either -1 or represents a pre-opened file descriptor for
   the test as returned by prepare_test_file.  */
int test_fd;

/*------------------------------------------------------------*/

/* Note that throughout this test we reopen, remove, and change
   to/from a fifo, the test file.  This would normally cause a race
   condition, except that we're in a test container.  No other process
   can run in the test container simultaneously.  */

void
prepare_test_data (void)
{
  buffer = (char *) xmalloc (bufsize);

#ifndef INDEPENDENT_PART
  /* Both file and pipe need this.  */
  if (test_file_name == NULL)
    {
      debug;
      int fd = create_temp_file ("tst-setvbuf2", &test_file_name);
      TEST_VERIFY_EXIT (fd != -1);
      struct stat64 st;
      xfstat64 (fd, &st);
      if (st.st_blksize > 0 && st.st_blksize < BUFSIZ)
	blksize = st.st_blksize;
      xclose (fd);
    }
#endif

  for (size_t i = 0; i < 2 * BUFSIZ; i++)
    {
      unsigned char c = TEST_STRING[i % strlen (TEST_STRING)];
      test_data[i] = c;
    }
}

#ifndef INDEPENDENT_PART

/* These functions provide a source/sink for the "other" side of any
   pipe-style descriptor we're using for test.  */

static pthread_t writer_thread_tid = 0;
static pthread_t reader_thread_tid = 0;

typedef struct {
  int fd;
  const char *fname;
} ThreadData;
/* It's OK if this is static, we only run one at a time.  */
ThreadData thread_data;

static void *
writer_thread_proc (void *closure)
{
  ThreadData *td = (ThreadData *) closure;
  int fd;
  int i;
  ssize_t wn;
  debug;

  if (td->fname)
    td->fd = xopen (td->fname, O_WRONLY, 0777);
  fd = td->fd;

  while (1)
    {
      i = 0;
      while (i < BUFSIZ)
	{
	  wn = write (fd, test_data + i, BUFSIZ - i);
	  if (wn <= 0)
	    break;
	  i += wn;
	}
    }
  return NULL;
}

static void *
reader_thread_proc (void *closure)
{
  ThreadData *td = (ThreadData *) closure;
  int fd;
  ssize_t rn;
  int n = 0;
  debug;

  if (td->fname)
    td->fd = xopen (td->fname, O_RDONLY, 0777);
  fd = td->fd;

  while (1)
    {
      char buf[BUFSIZ];
      rn = read (fd, buf, BUFSIZ);
      if (rn <= 0)
	break;
      TEST_COMPARE_BLOB (buf, rn, test_data+n, rn);
      n += rn;
    }
  return NULL;
}

static void
start_writer_thread (int fd)
{
  debug;
  thread_data.fd = fd;
  thread_data.fname = NULL;
  writer_thread_tid = xpthread_create (NULL, writer_thread_proc,
				       (void *)&thread_data);
}

static void
start_writer_thread_n (const char *fname)
{
  debug;
  thread_data.fd = 0;
  thread_data.fname = fname;
  writer_thread_tid = xpthread_create (NULL, writer_thread_proc,
				       (void *)&thread_data);
}

static void
end_writer_thread (void)
{
  debug;
  if (writer_thread_tid)
    {
      pthread_cancel (writer_thread_tid);
      xpthread_join (writer_thread_tid);
      xclose (thread_data.fd);
      writer_thread_tid = 0;
    }
}

static void
start_reader_thread (int fd)
{
  debug;
  thread_data.fd = fd;
  thread_data.fname = NULL;
  reader_thread_tid = xpthread_create (NULL, reader_thread_proc,
				       (void *)&thread_data);
}

static void
start_reader_thread_n (const char *fname)
{
  debug;
  thread_data.fd = 0;
  thread_data.fname = fname;
  reader_thread_tid = xpthread_create (NULL, reader_thread_proc,
				       (void *)&thread_data);
}

static void
end_reader_thread (void)
{
  debug;
  if (reader_thread_tid)
    {
      pthread_cancel (reader_thread_tid);
      xpthread_join (reader_thread_tid);
      xclose (thread_data.fd);
      reader_thread_tid = 0;
    }
}

/*------------------------------------------------------------*/

/* These two functions are reponsible for choosing a file to be tested
   against, typically by returning a filename but in a few cases also
   providing a file descriptor (i.e. for fdopen).  */

static const char *
prepare_test_file (enum test_source_case f, enum test_stream_case s)
{
  debug;

  test_fd = -1;

  switch (f)
    {
    case test_source_file:
      {
	if (test_stream_reads[f])
	  {
	    debug;
	    FILE *fp = xfopen (test_file_name, "w");
	    TEST_VERIFY_EXIT (fwrite (test_data, 1, 2 * BUFSIZ, fp)
			      == 2 * BUFSIZ);
	    xfclose (fp);
	  }
	debug;
	return test_file_name;
      }

    case test_source_pipe:
      {
	debug;
	xpipe (test_pipe);
	if (test_stream_reads[s])
	  {
	    start_writer_thread (test_pipe[1]);
	    test_fd = test_pipe[0];
	  }
	else
	  {
	    start_reader_thread (test_pipe[0]);
	    test_fd = test_pipe[1];
	  }
	test_pipe_name = xasprintf ("/proc/self/fd/%d", test_fd);
	debug;
	return test_pipe_name;
      }

    case test_source_fifo:
      {
	/* We do not want to fail/exit if the file doesn't exist.  */
	unlink (test_file_name);
	xmkfifo (test_file_name, 0600);
	debug;
	if (test_stream_reads[s])
	  start_writer_thread_n (test_file_name);
	else
	  start_reader_thread_n (test_file_name);
	debug;
	return test_file_name;
      }

    case test_source_pseudo_terminal:
      {
	support_openpty (&pty_fd, &test_fd, &test_pipe_name, NULL, NULL);

	debug;
	if (test_stream_reads[s])
	  start_writer_thread (pty_fd);
	else
	  start_reader_thread (pty_fd);

	debug;
	return test_pipe_name;
      }

    case test_source_dev_null:
	debug;
      return "/dev/null";

    default:
      abort ();
    }
}

static void
unprepare_test_file (FILE *fp,
		     enum test_source_case f,
		     enum test_stream_case s)
{
  debug;
  switch (f)
    {
    case test_source_file:
      break;

    case test_source_pipe:
      free (test_pipe_name);
      if (test_stream_reads[s])
	end_writer_thread ();
      else
	end_reader_thread ();
      break;

    case test_source_fifo:
      if (test_stream_reads[s])
	end_writer_thread ();
      else
	end_reader_thread ();
      unlink (test_file_name);
      break;

    case test_source_pseudo_terminal:
      free (test_pipe_name);
      if (test_stream_reads[s])
	end_writer_thread ();
      else
	end_reader_thread ();
      break;

    case test_source_dev_null:
      break;

    default:
      abort ();
    }
  debug;
}

/*------------------------------------------------------------*/

/* This function takes a filename and returns a file descriptor,
   opened according to the method requested.  */

static FILE *
open_test_stream (enum test_source_case f, enum test_stream_case s)
{
  int fd;
  FILE *fp;
  const char *fname;

  debug;
  fname = prepare_test_file (f, s);
  if (fname == NULL)
    return NULL;

  switch (s)
    {
    case test_stream_stdin:
      fp = xfopen (fname, "r");
      break;

    case test_stream_stdout:
      fp = xfopen (fname, "w");
      break;

    case test_stream_stderr:
      fp = xfopen (fname, "w");
      break;

    case test_stream_fopen_r:
      fp = xfopen (fname, "r");
      break;

    case test_stream_fdopen_r:
      if (test_fd == -1)
	fd = xopen (fname, O_RDONLY, 0);
      else
	fd = test_fd;
      fp = fdopen (fd, "r");
      break;

    case test_stream_fopen_w:
      fp = xfopen (fname, "w");
      break;

    case test_stream_fdopen_w:
      fd = xopen (fname, O_WRONLY|O_CREAT|O_TRUNC, 0777);
      fp = fdopen (fd, "w");
      break;

    default:
      abort ();
    }
  TEST_VERIFY_EXIT (fp != NULL);

  if (f == test_source_pseudo_terminal)
    {
      struct termios t;
      /* We disable the NL to CR-LF conversion so that we can compare
	 data without having to remove the extra CRs.  */
      if (tcgetattr (fileno (fp), &t) < 0)
	FAIL_EXIT1 ("tcgetattr failed: %m");
      t.c_oflag &= ~ONLCR;
      if (tcsetattr (fileno (fp), TCSANOW, &t) < 0)
	FAIL_EXIT1 ("tcsetattr failed: %m");
    }

  debug;
  printf ("source %s stream %s file %s fd %d\n",
	  test_source_name[f],
	  test_stream_name[s], fname, fileno (fp));
  return fp;
}

#endif

/*------------------------------------------------------------*/

/* These functions do the actual testing - setting various buffering
   options and verifying that they buffer as expected.  */

static void
test_put_string (FILE *fp, const char *s, int count)
{
  while (*s && count--)
    {
      fputc (*s++, fp);
      TEST_VERIFY_EXIT (!ferror (fp));
    }
}

int
verify_fully_buffered (FILE *fp,
		       enum test_source_case f,
		       enum test_stream_case s,
		       enum test_config_case c)
{
  debug;
  if (test_stream_reads[s])
    {
      char buf[10];
      dumpfp (fp);
      size_t fc = fread (buf, 1, 10 - 1, fp);
      dumpfp (fp);

      ssize_t count = fp->_IO_read_ptr - fp->_IO_read_base;

      TEST_VERIFY (fp->_IO_read_base != NULL);
      if (f == test_source_dev_null)
	{
	  TEST_VERIFY (fc == 0);
	  TEST_VERIFY (count == 0);
	}
      else if (f == test_source_pseudo_terminal)
	{
	  TEST_VERIFY (fc == 9);
	  TEST_VERIFY (count == 3 || count == 10);
	}
      else
	{
	  TEST_VERIFY (fc == 9);
	  TEST_VERIFY (count == 10);
	}

      /* We already checked for the first character being 'a'.  */
      if (count > 1)
	{
	  TEST_COMPARE_BLOB (buf, count - 1, test_data + 1, count - 1);
	  TEST_COMPARE_BLOB (fp->_IO_read_base, count, test_data, count);
	}
    }
  else
    {
      dumpfp (fp);
      test_put_string (fp, test_data + 1, 10 - 1);
      dumpfp (fp);
      TEST_COMPARE (fp->_IO_write_ptr - fp->_IO_write_base, 10);
      TEST_COMPARE_BLOB (fp->_IO_write_base, 10, test_data, 10);
    }

  TEST_COMPARE ((fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)), 0);
  if (c != test_config_none)
    TEST_COMPARE (__fbufsize (fp), bufsize);
  return 0;
}

int
verify_line_buffered (FILE *fp,
		      enum test_source_case f,
		      enum test_stream_case s,
		      enum test_config_case c)
{
  debug;
  /* "line buffered" for inputs is not really defined; what you really
     want here is to control the device providing input.  For GLIBC a
     line-buffered input is treated as fully buffered.  */
  if (test_stream_reads[s])
    {
      char buf[10];
      dumpfp (fp);
      size_t fc = fread (buf, 1, 10 - 1, fp);
      dumpfp (fp);

      ssize_t count = fp->_IO_read_ptr - fp->_IO_read_base;

      TEST_VERIFY (fp->_IO_read_base != NULL);
      if (f == test_source_dev_null)
	{
	  TEST_VERIFY (fc == 0);
	  TEST_VERIFY (count == 0);
	}
      else if (f == test_source_pseudo_terminal)
	{
	  TEST_VERIFY (fc == 9);
	  TEST_VERIFY (count == 3 || count == 10);
	}
      else
	{
	  TEST_VERIFY (fc == 9);
	  TEST_VERIFY (count == 10);
	}

      /* We already checked for the first character being 'a'.  */
      if (count > 1)
	{
	  TEST_COMPARE_BLOB (buf, count - 1, test_data + 1, count - 1);
	  TEST_COMPARE_BLOB (fp->_IO_read_base, count, test_data, count);
	}
    }
  else
    {
      dumpfp (fp);
      test_put_string (fp, test_data + 1, 10 - 1);
      dumpfp (fp);
      TEST_COMPARE (fp->_IO_write_ptr - fp->_IO_write_base, 3);
      /* The first "abcdef\n" got flushed, leaving "abc".  */
      TEST_COMPARE_BLOB (fp->_IO_write_base, 3, test_data + 7, 3);
    }

  TEST_COMPARE ((fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)), _IO_LINE_BUF);
  if (c != test_config_none)
    TEST_COMPARE (__fbufsize (fp), bufsize);
  return 0;
}

int
verify_unbuffered (FILE *fp,
		   enum test_source_case f,
		   enum test_stream_case s,
		   enum test_config_case c)
{
  debug;
  if (test_stream_reads[s])
    {
      /* We've already read one byte.  */
      dumpfp (fp);
      TEST_VERIFY (fp->_IO_read_base != NULL);
      if (f == test_source_dev_null)
	TEST_COMPARE (fp->_IO_read_ptr - fp->_IO_read_base, 0);
      else
	{
	  TEST_COMPARE (fp->_IO_read_ptr - fp->_IO_read_base, 1);
	  TEST_COMPARE (fp->_IO_read_base[0], test_data[0]);
	  TEST_VERIFY (fp->_IO_read_ptr == fp->_IO_read_end);
	}
    }
  else
    {
      dumpfp (fp);
      fputc (test_data[1], fp);
      dumpfp (fp);
      TEST_COMPARE (fp->_IO_write_ptr - fp->_IO_write_base, 0);
      TEST_COMPARE (fp->_IO_write_base[0], test_data[1]);
      TEST_VERIFY (fp->_IO_write_end == fp->_IO_write_base);
    }
  TEST_COMPARE ((fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF)),
	       _IO_UNBUFFERED);
  TEST_COMPARE (__fbufsize (fp), 1);
  return 0;
}

static int
do_setvbuf (FILE *fp, void *buf, int flags, int size,
	    enum test_stream_case s)
{
  if (s != test_stream_stdout)
    printf ("SETVBUF %p %p %s %d\n",
	    fp, buf,
	    flags == _IONBF ? "_IONBF"
	    : flags == _IOLBF ? "_IOLBF"
	    : flags == _IOFBF ? "_IOFBF"
	    : "???", size);
  if (setvbuf (fp, buf, flags, size))
    {
      perror ("setvbuf");
      return 1;
    }
  return 0;
}

int
do_second_part (FILE *fp,
		enum test_source_case f,
		enum test_stream_case s,
		enum test_config_case c)
{
  /* At this point, FP is the stream to test according to the other
     parameters.  */

  int rv = 0;
  int flags_before;
  int flags_after;

  debug;

  flags_before = fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF);

  /* This is where we do the thing we're testing for.  */
  switch (c)
    {
    case test_config_none:
      /* Buffering is unchanged.  */
      break;

    case test_config_unbuffered:
      do_setvbuf (fp, NULL, _IONBF, 0, s);
      break;

    case test_config_line:
      do_setvbuf (fp, buffer, _IOLBF, bufsize, s);
      break;

    case test_config_fully:
      do_setvbuf (fp, buffer, _IOFBF, bufsize, s);
      break;

    default:
      abort ();
    }

  flags_after = fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF);

  /* Check the buffer mode after we touch it, if we touched it.  */
  switch (c)
    {
    case test_config_none:
      /* Buffering is unchanged, but may change on the first read/write.  */
      TEST_COMPARE (flags_after, flags_before);
      break;

    case test_config_unbuffered:
      TEST_COMPARE (flags_after, _IO_UNBUFFERED);
      break;

    case test_config_line:
      TEST_COMPARE (flags_after, _IO_LINE_BUF);
      break;

    case test_config_fully:
      TEST_COMPARE (flags_after, 0);
      break;

    default:
      abort ();
    }

  /* Glibc defers calculating the appropriate buffering mechanism
     until it reads from or writes to the device.  So we read one
     character here, and account for that in the tests.  */
  if (test_stream_reads[s])
    {
      dumpfp (fp);
      int c = fgetc (fp);
      if (c != TEST_STRING[0] && f != test_source_dev_null)
	FAIL ("first char read is %c not %c", c, TEST_STRING[0]);
      dumpfp (fp);
    }
  else
    {
      dumpfp (fp);
      fputc (TEST_STRING[0], fp);
      dumpfp (fp);
    }

  switch (fp->_flags & (_IO_UNBUFFERED | _IO_LINE_BUF))
    {
    case _IO_LINE_BUF:
      rv += verify_line_buffered (fp, f, s, c);
      break;

    case _IO_UNBUFFERED:
      rv += verify_unbuffered (fp, f, s, c);
      break;

    case 0: /* Fully buffered.  */
      rv += verify_fully_buffered (fp, f, s, c);
      break;

    default:
      abort ();
    }


  fclose (fp);
  return rv;
}

/*------------------------------------------------------------*/

#ifdef INDEPENDENT_PART
/* This part is the independent sub-process we call to test stdin et
   al.  */

int
main (int argc, char **argv)
{
  /* This is one of the subprocesses we created to test stdin et
     al.  */
  FILE *fp;

  /* If we're called as a regular test, instead of as a sub-process,
     don't complain.  */
  if (argc == 1)
    return 0;

  if (argc != 4)
    {
      int i;
      for (i = 0; i <= argc; i ++)
	printf ("argv[%d] = `%s'\n", i, argv[i] ?: "(null)");
      FAIL_EXIT1 ("sub-process called wrong");
    }

  prepare_test_data ();

  enum test_source_case f = atoi (argv[1]);
  enum test_stream_case s = atoi (argv[2]);
  enum test_config_case c = atoi (argv[3]);

  if (s != test_stream_stdout)
    printf ("\n\033[41mRunning test %s : %s : %s\033[0m\n",
	    test_source_name[f],
	    test_stream_name[s],
	    test_config_name[c]);

  switch (s)
    {
    case test_stream_stdin:
      fp = stdin;
      break;
    case test_stream_stdout:
      fp = stdout;
      break;
    case test_stream_stderr:
      fp = stderr;
      break;
    default:
      abort ();
    }

  return do_second_part (fp, f, s, c);
}

#else
/* This part is the standard test process.  */

/* Spawn an independent sub-process with std* redirected.  */
int
recurse (FILE *fp,
	 enum test_source_case f,
	 enum test_stream_case s,
	 enum test_config_case c)
{
  /* We need to test stdin, stdout, or stderr, which means creating a
     subprocess with one of those redirected from FP.  */
  debug;

  pid_t pid;
  int status;

  pid = fork ();

  switch (pid)
    {
    case -1: /* error */
      perror ("fork");
      return 1;
      break;

    default: /* parent */
      fclose (fp);
      xwaitpid (pid, &status, 0);
      if (WIFEXITED (status)
	  && WEXITSTATUS (status) == 0)
	return 0;
      return 1;

    case 0: /* child */
      switch (s)
	{
	case test_stream_stdin:
	  xclose (0);
	  dup2 (fileno (fp), 0);
	  break;
	case test_stream_stdout:
	  xclose (1);
	  dup2 (fileno (fp), 1);
	  break;
	case test_stream_stderr:
	  xclose (2);
	  dup2 (fileno (fp), 2);
	  break;
	default:
	  abort ();
	}
      fclose (fp);

      /* At this point, we have to run a program... which is tricky to
	 properly support for remote targets or crosses, because of
	 glibc versions etc.  Hence we run in a test-container.  */

      char fs[10], ss[10], cs[10];
      sprintf (fs, "%d", f);
      sprintf (ss, "%d", s);
      sprintf (cs, "%d", c);
      execl (IND_PROC, IND_PROC, fs, ss, cs, NULL);
      if (s == test_stream_stdout)
	fprintf (stderr, "execl (%s) failed, ", IND_PROC);
      else
	printf ("execl (%s) failed, ", IND_PROC);
      perror ("The error was");
      exit (1);
      break;
    }

  return 0;
}

int
do_test (void)
{
  int rv = 0;

  signal (SIGPIPE, SIG_IGN);

  prepare_test_data ();

  for (enum test_source_case f = 0; f < test_source_count; ++f)
    for (enum test_stream_case s = 0; s < test_stream_count; ++s)
      for (enum test_config_case c = 0; c < test_config_count; ++c)
	{
	  printf ("\n\033[43mRunning test %s : %s : %s\033[0m\n",
		  test_source_name[f],
		  test_stream_name[s],
		  test_config_name[c]);

	  FILE *fp = open_test_stream (f, s);

	  if (fp)
	    {

	      if (s <= test_stream_stderr)
		rv += recurse (fp, f, s, c);
	      else
		rv += do_second_part (fp, f, s, c);

	      unprepare_test_file (fp, f, s);
	    }
	}

  free (buffer);

  printf ("return %d\n", rv);
  return rv;
}

# include <support/test-driver.c>
#endif