/* Tests for monitoring file descriptor usage.

   Copyright (C) 2018 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

   <http://www.gnu.org/licenses/>.  */

#include <fcntl.h>

#include <stdbool.h>

#include <stdlib.h>

#include <string.h>

#include <support/capture_subprocess.h>

#include <support/check.h>

#include <support/descriptors.h>

#include <support/support.h>

#include <support/xunistd.h>

/* This is the next free descriptor that the subprocess will pick.  */

static int free_descriptor;

static void

subprocess_no_change (void *closure)

{

  struct support_descriptors *descrs = support_descriptors_list ();

  int fd = xopen ("/dev/null", O_WRONLY, 0);

  TEST_COMPARE (fd, free_descriptor);

  xclose (fd);

  support_descriptors_free (descrs);

}

static void

subprocess_closed_descriptor (void *closure)

{

  int fd = xopen ("/dev/null", O_WRONLY, 0);

  TEST_COMPARE (fd, free_descriptor);

  struct support_descriptors *descrs = support_descriptors_list ();

  xclose (fd);

  support_descriptors_check (descrs); /* Will report failure.  */

  puts ("EOT");

  support_descriptors_free (descrs);

}

static void

subprocess_opened_descriptor (void *closure)

{

  struct support_descriptors *descrs = support_descriptors_list ();

  int fd = xopen ("/dev/null", O_WRONLY, 0);

  TEST_COMPARE (fd, free_descriptor);

  support_descriptors_check (descrs); /* Will report failure.  */

  puts ("EOT");

  support_descriptors_free (descrs);

}

static void

subprocess_changed_descriptor (void *closure)

{

  int fd = xopen ("/dev/null", O_WRONLY, 0);

  TEST_COMPARE (fd, free_descriptor);

  struct support_descriptors *descrs = support_descriptors_list ();

  xclose (fd);

  TEST_COMPARE (xopen ("/dev", O_DIRECTORY | O_RDONLY, 0), fd);

  support_descriptors_check (descrs); /* Will report failure.  */

  puts ("EOT");

  support_descriptors_free (descrs);

}

static void

report_subprocess_output (const char *name,

                          struct support_capture_subprocess *proc)

{

  printf ("info: BEGIN %s output\n"

          "%s"

          "info: END %s output\n",

          name, proc->out.buffer, name);

}

/* Use an explicit flag to preserve failure status across

   support_record_failure_reset calls.  */

static bool good = true;

static void

test_run (void)

{

  struct support_capture_subprocess proc = support_capture_subprocess

    (&subprocess_no_change, NULL);

  support_capture_subprocess_check (&proc, "subprocess_no_change",

                                    0, sc_allow_none);

  support_capture_subprocess_free (&proc;;

  char *expected = xasprintf ("\nDifferences:\n"

                              "error: descriptor %d was closed\n"

                              "EOT\n",

                              free_descriptor);

  good = good && !support_record_failure_is_failed ();

  proc = support_capture_subprocess (&subprocess_closed_descriptor, NULL);

  good = good && support_record_failure_is_failed ();

  support_record_failure_reset (); /* Discard the reported error.  */

  report_subprocess_output ("subprocess_closed_descriptor", &proc;;

  TEST_VERIFY (strstr (proc.out.buffer, expected) != NULL);

  support_capture_subprocess_check (&proc, "subprocess_closed_descriptor",

                                    0, sc_allow_stdout);

  support_capture_subprocess_free (&proc;;

  free (expected);

  expected = xasprintf ("\nDifferences:\n"

                        "error: descriptor %d was opened (\"/dev/null\")\n"

                        "EOT\n",

                        free_descriptor);

  good = good && !support_record_failure_is_failed ();

  proc = support_capture_subprocess (&subprocess_opened_descriptor, NULL);

  good = good && support_record_failure_is_failed ();

  support_record_failure_reset (); /* Discard the reported error.  */

  report_subprocess_output ("subprocess_opened_descriptor", &proc;;

  TEST_VERIFY (strstr (proc.out.buffer, expected) != NULL);

  support_capture_subprocess_check (&proc, "subprocess_opened_descriptor",

                                    0, sc_allow_stdout);

  support_capture_subprocess_free (&proc;;

  free (expected);

  expected = xasprintf ("\nDifferences:\n"

                        "error: descriptor %d changed from \"/dev/null\""

                        " to \"/dev\"\n"

                        "error: descriptor %d changed ino ",

                        free_descriptor, free_descriptor);

  good = good && !support_record_failure_is_failed ();

  proc = support_capture_subprocess (&subprocess_changed_descriptor, NULL);

  good = good && support_record_failure_is_failed ();

  support_record_failure_reset (); /* Discard the reported error.  */

  report_subprocess_output ("subprocess_changed_descriptor", &proc;;

  TEST_VERIFY (strstr (proc.out.buffer, expected) != NULL);

  support_capture_subprocess_check (&proc, "subprocess_changed_descriptor",

                                    0, sc_allow_stdout);

  support_capture_subprocess_free (&proc;;

  free (expected);

}

static int

do_test (void)

{

  puts ("info: initial descriptor set");

  {

    struct support_descriptors *descrs = support_descriptors_list ();

    support_descriptors_dump (descrs, "info:  ", stdout);

    support_descriptors_free (descrs);

  }

  free_descriptor = xopen ("/dev/null", O_WRONLY, 0);

  puts ("info: descriptor set with additional free descriptor");

  {

    struct support_descriptors *descrs = support_descriptors_list ();

    support_descriptors_dump (descrs, "info:  ", stdout);

    support_descriptors_free (descrs);

  }

  TEST_VERIFY (free_descriptor >= 3);

  xclose (free_descriptor);

  /* Initial test run without a sentinel descriptor.  The presence of

     such a descriptor exercises different conditions in the list

     comparison in support_descriptors_check.  */

  test_run ();

  /* Allocate a sentinel descriptor at the end of the descriptor list,

     after free_descriptor.  */

  int sentinel_fd;

  {

    int fd = xopen ("/dev/full", O_WRONLY, 0);

    TEST_COMPARE (fd, free_descriptor);

    sentinel_fd = dup (fd);

    TEST_VERIFY_EXIT (sentinel_fd > fd);

    xclose (fd);

  }

  puts ("info: descriptor set with sentinel descriptor");

  {

    struct support_descriptors *descrs = support_descriptors_list ();

    support_descriptors_dump (descrs, "info:  ", stdout);

    support_descriptors_free (descrs);

  }

  /* Second test run with sentinel descriptor.  */

  test_run ();

  xclose (sentinel_fd);

  return !good;

}

#include <support/test-driver.c>