Add new tests for fopen

  Adding some basic tests for fopen, testing different modes, stream
positioning and concurrent read/write operation on files.
---
 stdio-common/Makefile                |   1 +
 stdio-common/tst-fopen.c             | 279 +++++++++++++++++++++++++++
 sysdeps/pthread/Makefile             |   1 +
 sysdeps/pthread/tst-fopen-threaded.c | 249 ++++++++++++++++++++++++
 4 files changed, 530 insertions(+)
 create mode 100644 stdio-common/tst-fopen.c
 create mode 100644 sysdeps/pthread/tst-fopen-threaded.c
  

Copyright years need updating throughout...

Missing xpthread_barrier_init() in threaded test 2

Martin Coufal <mcoufal@redhat.com> writes:
> Adding some basic tests for fopen, testing different modes, stream
> positioning and concurrent read/write operation on files.

> diff --git a/stdio-common/Makefile b/stdio-common/Makefile
>    tst-fmemopen2 \
>    tst-fmemopen3 \
>    tst-fmemopen4 \
> +  tst-fopen \
>    tst-fphex \

Ok.

> diff --git a/stdio-common/tst-fopen.c b/stdio-common/tst-fopen.c
> +/* Basic test for fopen.
> +   Copyright (C) 2024 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/>.  */
> +
> +#include <errno.h>
> +#include <stdio.h>
> +#include <string.h>
> +#include <unistd.h>
> +
> +#include <support/check.h>
> +#include <support/temp_file.h>
> +#include <support/xstdio.h>

Ok.

> +#define APPENDED_TEXT "This is appended text. "
> +#define DEFAULT_TEXT "Lorem ipsum dolor sit amet, consectetur " \
> +  "adipiscing elit, sed do eiusmod tempor incididunt ut labore et " \
> +  "dolore magna aliqua."
> +#define MAX_BUFFER_SIZE 300

Ok.

> +
> +static int
> +do_test (void)
> +{
> +  char *temp_file;
> +  FILE *fd_file = NULL;
> +  char read_buffer[MAX_BUFFER_SIZE] = "";
> +  size_t ret;

Ok.

> +  /* Prepare files. */
> +  int fd = create_temp_file ("tst-fopen.", &temp_file);
> +  TEST_VERIFY_EXIT (fd != -1);
> +  fd_file = fdopen (fd, "w");
> +  ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
> +  xfclose (fd_file);

Ok.  File has "DEFAULT_TEXT"

> +  /* Test 1: This checks for fopen with mode "r".  Open text file for
> +     reading.  The stream is positioned at the beginning of the file. */
> +  printf ("Test 1: This checks for fopen with mode \"r\".\n");
> +  fd_file = fopen (temp_file, "r");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  /* Read should succeed. */
> +  ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
> +  TEST_VERIFY (strcmp (read_buffer, DEFAULT_TEXT) == 0);

Ok.

> +  /* Write should fail. */
> +  errno = 0;
> +  ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> +  TEST_VERIFY (ferror (fd_file) != 0);
> +  TEST_COMPARE (errno, EBADF);
> +  TEST_COMPARE (ret, 0);
> +  clearerr (fd_file);

Ok.

> +  /* Opening non-existent file should fail. */
> +  xfclose (fd_file);
> +  errno = 0;
> +  fd_file = fopen ("file-that-does-not-exist", "r");
> +  TEST_VERIFY (fd_file == NULL);
> +  TEST_COMPARE (errno, ENOENT);
> +  TEST_VERIFY (fd_file == NULL);

Ok.

> +  memset (read_buffer, 0, MAX_BUFFER_SIZE);

Ok.

> +  /* Test 2: This checks for fopen with mode "r+".  Open for reading and
> +     writing.  The stream is positioned at the beginning of the file. */
> +  printf ("Test 2: This checks for fopen with mode \"r+\".\n");
> +  fd_file = fopen (temp_file, "r+");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  /* Read should succeed. */
> +  ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT));
> +  TEST_VERIFY (strcmp (read_buffer, DEFAULT_TEXT) == 0);

Ok.

> +  fflush (fd_file);
> +  /* File position indicator expected at 0 + read bytes. */
> +  TEST_COMPARE (ftell (fd_file), ret);

Ok.

> +  /* Write should succeed. */
> +  ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT));

Ok.

> +  /* Opening non-existent file should fail. */
> +  xfclose (fd_file);
> +  errno = 0;
> +  fd_file = fopen ("file-that-does-not-exist", "r+");
> +  TEST_VERIFY (fd_file == NULL);
> +  TEST_COMPARE (errno, ENOENT);
> +  TEST_VERIFY (fd_file == NULL);

Ok.

> +  memset (read_buffer, 0, MAX_BUFFER_SIZE);
> +
> +  /* Test 3: This checks for fopen with mode "w".  Truncate file to zero
> +     length or create text file for writing.  The stream is positioned
> +     at the beginning of the file. */
> +  printf ("Test 3: This checks for fopen with mode \"w\".\n");
> +  fd_file = fopen (temp_file, "w");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  /* Read should fail. */
> +  errno = 0;
> +  ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> +  TEST_VERIFY (ferror (fd_file) != 0);
> +  TEST_COMPARE (errno, EBADF);
> +  TEST_COMPARE (ret, 0);

Ok.

> +  clearerr (fd_file);
> +  /* Write should succeed. */
> +  ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT));

Ok.

> +  /* Opening non-existent file should succeed. */
> +  xfclose (fd_file);
> +  fd_file = fopen ("/tmp/file-that-does-not-exist", "w");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  xfclose (fd_file);
> +  remove ("/tmp/file-that-does-not-exist");
> +  memset (read_buffer, 0, MAX_BUFFER_SIZE);

Ok.

> +  /* Test 4: This checks for fopen with mode "w+".  Open for reading and
> +     writing.  The file is created if it does not exist, otherwise it is
> +     truncated.  The stream is positioned at the beginning of the file.
> +   */
> +  printf ("Test 4: This checks for fopen with mode \"w+\".\n");
> +  fd_file = fopen (temp_file, "w+");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  /* Read should succeed. */
> +  ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, 0);
> +  TEST_VERIFY (read_buffer[0] == '\0');

Ok.

> +  /* Write should succeed. */
> +  ret = fwrite (DEFAULT_TEXT, sizeof (char), strlen (DEFAULT_TEXT), fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT));

Ok.

> +  /* Opening non-existent file should succeed. */
> +  xfclose (fd_file);
> +  fd_file = fopen ("/tmp/file-that-does-not-exist", "w+");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  xfclose (fd_file);
> +  remove ("/tmp/file-that-does-not-exist");
> +  memset (read_buffer, 0, MAX_BUFFER_SIZE);

Ok.

> +  /* Test 5: This checks for fopen with mode "a".  Open for appending
> +     (writing at end of file).  The file is created if it does not
> +     exist.  The stream is positioned at the end of the file. */
> +  printf ("Test 5: This checks for fopen with mode \"a\".\n");
> +  fd_file = fopen (temp_file, "a");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), strlen (DEFAULT_TEXT));

Ok.

> +  /* Read should fail. */
> +  errno = 0;
> +  ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> +  TEST_VERIFY (ferror (fd_file) != 0);
> +  TEST_COMPARE (errno, EBADF);
> +  TEST_COMPARE (ret, 0);

Ok.

> +  clearerr (fd_file);
> +  /* Write should succeed. */
> +  ret = fwrite (APPENDED_TEXT, sizeof (char), strlen (APPENDED_TEXT), fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (APPENDED_TEXT));

Ok.

> +  /* The file position indicator for the stream is advanced by the
> +   *  number of bytes successfully read or written. */
> +  TEST_COMPARE (ftell (fd_file), strlen (DEFAULT_TEXT) + ret);

Ok.

> +  /* Opening non-existent file should succeed. */
> +  xfclose (fd_file);
> +  fd_file = fopen ("/tmp/file-that-does-not-exist", "a");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  xfclose (fd_file);
> +  remove ("/tmp/file-that-does-not-exist");
> +  memset (read_buffer, 0, MAX_BUFFER_SIZE);

Ok.

> +  /* Test 6: This checks for fopen with mode "a+".  Open for reading and
> +     appending (writing at end of file).  The file is created if it does
> +     not exist.  Output is always appended to the end of the file.  The
> +     initial file position for reading is at the beginning of the file,
> +     but it is advanced to the end prior to each write. */
> +  printf ("Test 6: This checks for fopen with mode \"a+\".\n");
> +  errno = 0;
> +  fd_file = fopen (temp_file, "a+");
> +  TEST_COMPARE (errno, 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  /* Read should succeed. */
> +  ret = fread (read_buffer, sizeof (char), MAX_BUFFER_SIZE, fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (DEFAULT_TEXT) + strlen (APPENDED_TEXT));
> +  TEST_VERIFY (strcmp (read_buffer, DEFAULT_TEXT APPENDED_TEXT) == 0);

Ok.

> +  /* Write should succeed. */
> +  const char* SECOND_APPEND = "This is second append.";
> +  ret = fwrite (SECOND_APPEND, sizeof (char), strlen (SECOND_APPEND), fd_file);
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_COMPARE (ret, strlen (SECOND_APPEND));

Ok.

> +  /* The file position indicator for the stream is advanced by the
> +     number of bytes successfully read or written. */
> +  TEST_COMPARE (ftell (fd_file),
> +                strlen (DEFAULT_TEXT) + strlen (APPENDED_TEXT) + ret);

Ok.

> +  /* Opening non-existent file should succeed. */
> +  xfclose (fd_file);
> +  fd_file = fopen ("/tmp/file-that-does-not-exist", "a+");
> +  TEST_COMPARE (ferror (fd_file), 0);
> +  TEST_VERIFY (fd_file != NULL);
> +  TEST_COMPARE (ftell (fd_file), 0);

Ok.

> +  xfclose (fd_file);
> +  remove ("/tmp/file-that-does-not-exist");
> +  memset (read_buffer, 0, MAX_BUFFER_SIZE);

Ok.

> +  /* Test 7: This checks for fopen with other valid modes set, such as
> +     "rc", "we" or "am".  The test calls fopen with these modes and
> +     checks that no errors appear.  */
> +  printf ("Test 7: This checks for fopen with other valid modes set, "
> +          "such as \"rc\", \"we\" or \"am\".\n");
> +  /* These modes all operate correctly with the file already present. */
> +  static const char *valid_modes[] =
> +    { "rc", "we", "am", "r+x", "wb+", "ab", 0 };
> +  const char **p = valid_modes;
> +  while (*p != 0)
> +    {
> +      fd_file = fopen (temp_file, *p);
> +      TEST_COMPARE (ferror (fd_file), 0);
> +      TEST_VERIFY (fd_file != NULL);
> +      xfclose (fd_file);
> +      ++p;
> +    }

Ok.

> +  /* Test 8: This checks for fopen with invalid modes.  The test calls
> +     fopen with these modes and checks that opening existing files with
> +     invalid mode fails and that opening non-existing files with invalid
> +     mode doesn't create a new file. */
> +  printf ("Test 8: This checks for fopen with invalid modes.\n");
> +  static const char *invalid_modes[] = { "0", "tr", "z", "x", " ", 0 };
> +  p = invalid_modes;
> +  while (*p != 0)
> +    {
> +      errno = 0;
> +      fd_file = fopen (temp_file, *p);
> +      TEST_VERIFY (fd_file == NULL);
> +      TEST_COMPARE (errno, EINVAL);
> +      errno = 0;
> +      fd_file = fopen ("/tmp/file-that-does-not-exist", *p);
> +      TEST_VERIFY (fd_file == NULL);
> +      TEST_COMPARE (errno, EINVAL);
> +      ++p;
> +      TEST_VERIFY (access ("/tmp/file-that-does-not-exist", F_OK) == -1);
> +    }

Ok.

> +  return 0;
> +}
> +
> +#include <support/test-driver.c>

Ok.

> diff --git a/sysdeps/pthread/Makefile b/sysdeps/pthread/Makefile
> index a123e28a57..5947db43f3 100644
> --- a/sysdeps/pthread/Makefile
> +++ b/sysdeps/pthread/Makefile
> @@ -154,6 +154,7 @@ tests += \
>    tst-exit3 \
>    tst-flock1 \
>    tst-flock2 \
> +  tst-fopen-threaded \
>    tst-fork1 \
>    tst-fork2 \
>    tst-fork3 \

Ok.

> diff --git a/sysdeps/pthread/tst-fopen-threaded.c b/sysdeps/pthread/tst-fopen-threaded.c
> new file mode 100644
> index 0000000000..07bcea16db
> --- /dev/null
> +++ b/sysdeps/pthread/tst-fopen-threaded.c
> @@ -0,0 +1,249 @@
> +/* Test for fread and fwrite with multiple threads.
> +   Copyright (C) 2024 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/>. */
> +
> +/* Description of test intent.
> +   The test creates NUM_THREADS threads for reading and writing to the
> +   prepared file.  The prepared file contains 'NUM_THREADS - 1' bytes
> +   where each byte is unique number from 0 to 'NUM_THREADS - 2'.  If all
> +   operations are correctly multi-threaded safe then all concurent read
> +   operations should succeed and read a unique 1 byte value.  The last
> +   thread to read should get an EOF.  In concurrent write, all write
> +   operations should succeed and the file should contain all unique 1
> +   byte values from 0 to 'NUM_THREADS - 1'.  Both concurrent read and
> +   concurrent write tests are repeated ITERS times to increase
> +   the probability of detecting concurrency issues.  */
> +
> +#include <errno.h>
> +#include <pthread.h>
> +#include <stdbool.h>
> +#include <stdio.h>
> +#include <string.h>
> +#include <unistd.h>
> +
> +#include <support/check.h>
> +#include <support/temp_file.h>
> +#include <support/xstdio.h>
> +#include <support/xthread.h>
> +
> +#define NUM_THREADS 100
> +#define ITERS 10

Ok.

> +char *temp_file;
> +pthread_barrier_t barrier;
> +
> +struct thread_data
> +{
> +  FILE *fd;
> +  /* Read value or value to be written.  */
> +  unsigned char value;
> +  bool eof;
> +};

Ok.

> +static void *
> +threadReadRoutine (void *argv)
> +{
> +  struct thread_data *my_data;
> +  unsigned char read_buffer;
> +  int ret = 0;
> +  my_data = (struct thread_data *) argv;
> +  /* Wait for all threads to be ready to read.  */
> +  xpthread_barrier_wait (&barrier);

Ok.

> +  ret =
> +    fread (&read_buffer, sizeof (char), sizeof (read_buffer), my_data->fd);
> +  if (feof (my_data->fd) != 0)
> +    {
> +      clearerr (my_data->fd);
> +      my_data->eof = true;
> +    }
> +  else
> +    {
> +      TEST_COMPARE (ret, 1);
> +      /* Save the read value.  */
> +      my_data->value = read_buffer;
> +    }
> +  TEST_COMPARE (ferror (my_data->fd), 0);
> +  return NULL;
> +}

Ok.

> +void *
> +threadWriteRoutine (void *argv)
> +{
> +  struct thread_data *my_data;
> +  int ret = 0;
> +  my_data = (struct thread_data *) argv;
> +  /* Wait for all threads to be ready to write.  */
> +  xpthread_barrier_wait (&barrier);

Ok.

> +  ret = fwrite (&my_data->value, sizeof (unsigned char), 1, my_data->fd);
> +  TEST_COMPARE (ferror (my_data->fd), 0);
> +  TEST_COMPARE (feof (my_data->fd), 0);
> +  TEST_COMPARE (ret, 1);
> +  return NULL;
> +}

Ok.

> +void *
> +threadOpenCloseRoutine (void *argv)
> +{
> +  /* Wait for all threads to be ready to call fopen and fclose.  */
> +  xpthread_barrier_wait (&barrier);
> +
> +  FILE *fd = xfopen ("/tmp/openclosetest", "w+");
> +  xfclose (fd);
> +  return NULL;
> +}

Ok.

> +static int
> +do_test (void)
> +{
> +  FILE *fd_file = NULL;
> +  unsigned char buffer[NUM_THREADS] = "0";
> +  size_t ret = 0;
> +  pthread_t threads[NUM_THREADS];
> +  struct thread_data thread_data_array[NUM_THREADS];
> +  bool present_values[NUM_THREADS] = { false };

Ok.

> +  /* Prepare files.  */
> +  for (int i = 0; i < NUM_THREADS; i++)
> +    buffer[i] = i;

Ok.

> +  int fd = create_temp_file ("tst-fopen.", &temp_file);
> +  TEST_VERIFY_EXIT (fd != -1);
> +  fd_file = fdopen (fd, "w");

Ok.

> +  /* NUM_THREADS - 1: last thread will read EOF */
> +  ret = fwrite (buffer, sizeof (unsigned char), NUM_THREADS - 1, fd_file);
> +  TEST_COMPARE (ret, NUM_THREADS - 1);
> +  xfclose (fd_file);

Ok.

> +  /* Test 1: Concurrent read.  */
> +  for (int reps = 1; reps <= ITERS; reps++)
> +    {
> +      fd_file = xfopen (temp_file, "r");
> +      xpthread_barrier_init (&barrier, NULL, NUM_THREADS);
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          thread_data_array[i].fd = fd_file;
> +          /* Initialize with highest possible value so it's easier to debug if
> +             anything goes wrong.  */
> +          thread_data_array[i].value = 255;
> +          thread_data_array[i].eof = false;
> +
> +          threads[i] =
> +            xpthread_create (support_small_stack_thread_attribute (),
> +                             threadReadRoutine,
> +                             (void *) &thread_data_array[i]);
> +        }
> +
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          xpthread_join (threads[i]);
> +        }
> +      xpthread_barrier_destroy (&barrier);
> +      xfclose (fd_file);

Ok.

> +      /* Verify read values.  */
> +      int eof_cnt = 0;
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        present_values[i] = false;
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          if (thread_data_array[i].eof)
> +            {
> +              /* EOF was read.  */
> +              present_values[NUM_THREADS - 1] = true;
> +              eof_cnt++;
> +            }
> +          else
> +            {
> +              /* The same value shouldn't be read twice.  */
> +              TEST_VERIFY (!present_values[thread_data_array[i].value]);
> +              present_values[thread_data_array[i].value] = true;
> +            }
> +        }
> +      /* EOF is read exactly once.  */
> +      TEST_COMPARE (eof_cnt, 1);
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          /* All values should be read.  */
> +          TEST_VERIFY (present_values[i]);
> +        }
> +    }

Ok.

> +  /* Test 2: Concurrent write.  */
> +  for (int reps = 1; reps <= ITERS; reps++)
> +    {
> +      fd_file = xfopen (temp_file, "w");

You need a xpthread_barrier_init() here.

> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          thread_data_array[i].fd = fd_file;
> +          thread_data_array[i].value = i;
> +
> +          threads[i] =
> +            xpthread_create (support_small_stack_thread_attribute (),
> +                             threadWriteRoutine,
> +                             (void *) &thread_data_array[i]);
> +        }
> +
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          xpthread_join (threads[i]);
> +        }
> +      xpthread_barrier_destroy (&barrier);
> +      xfclose (fd_file);

Ok.

> +      /* Verify written values.  */
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        present_values[i] = false;
> +      memset (buffer, 0, NUM_THREADS);
> +      fd_file = xfopen (temp_file, "r");
> +      ret = fread (buffer, sizeof (unsigned char), NUM_THREADS, fd_file);
> +      TEST_COMPARE (ret, NUM_THREADS);

Ok.

> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          /* The same value shouldn't be written twice.  */
> +          TEST_VERIFY (!present_values[buffer[i]]);
> +          present_values[buffer[i]] = true;
> +        }

Ok.

> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          /* All values should be written.  */
> +          TEST_VERIFY (present_values[i]);
> +        }
> +      xfclose (fd_file);
> +    }

Ok.

> +  /* Test 3: Concurrent open/close.  */
> +  for (int reps = 1; reps <= ITERS; reps++)
> +    {
> +      xpthread_barrier_init (&barrier, NULL, NUM_THREADS);
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          threads[i] =
> +            xpthread_create (support_small_stack_thread_attribute (),
> +                             threadOpenCloseRoutine, NULL);
> +        }
> +      for (int i = 0; i < NUM_THREADS; i++)
> +        {
> +          xpthread_join (threads[i]);
> +        }
> +      xpthread_barrier_destroy (&barrier);
> +    }
> +
> +  return 0;
> +}
> +
> +#include <support/test-driver.c>

Ok.