/* Copyright (C) 2017-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/>.  */

/* fprintf is a cancellation point, but getopt is not supposed to be a

   cancellation point, even when it prints error messages.  */

/* Note: getopt.h must be included first in this file, so we get the

   GNU getopt rather than the POSIX one.  */

#include <getopt.h>

#include <stdbool.h>

#include <stdio.h>

#include <stdlib.h>

#include <fcntl.h>

#include <pthread.h>

#include <unistd.h>

#include <support/support.h>

#include <support/temp_file.h>

#include <support/xthread.h>

static bool

check_stderr (bool expect_errmsg, FILE *stderr_trapped)

{

  static char *lineptr = 0;

  static size_t linesz = 0;

  bool got_errmsg = false;

  rewind (stderr_trapped);

  while (getline (&lineptr, &linesz, stderr_trapped) > 0)

    {

      got_errmsg = true;

      fputs (lineptr, stdout);

    }

  rewind (stderr_trapped);

  ftruncate (fileno (stderr_trapped), 0);

  return got_errmsg == expect_errmsg;

}

struct test_short

{

  const char *label;

  const char *opts;

  const char *const argv[8];

  int argc;

  bool expect_errmsg;

};

struct test_long

{

  const char *label;

  const char *opts;

  const struct option longopts[4];

  const char *const argv[8];

  int argc;

  bool expect_errmsg;

};

#define DEFINE_TEST_DRIVER(test_type, getopt_call)			\

  struct test_type##_tdata						\

  {									\

    pthread_mutex_t *sync;						\

    const struct test_type *tcase;					\

    bool ok;								\

  };									\

									\

  static void *								\

  test_type##_threadproc (void *data)					\

  {									\

    struct test_type##_tdata *tdata = data;				\

    const struct test_type *tc = tdata->tcase;				\

									\

    xpthread_mutex_lock (tdata->sync);					\

    xpthread_mutex_unlock (tdata->sync);				\

									\

    /* At this point, this thread has a cancellation pending.		\

       We should still be able to get all the way through a getopt	\

       loop without being cancelled.					\

       Setting optind to 0 forces getopt to reinitialize itself.  */	\

    optind = 0;								\

    opterr = 1;								\

    optopt = 0;								\

    while (getopt_call != -1)						\

      ;									\

    tdata->ok = true;							\

									\

    pthread_testcancel();						\

    return 0;								\

  }									\

									\

  static bool								\

  do_##test_type (const struct test_type *tcase, FILE *stderr_trapped)	\

  {									\

    pthread_mutex_t sync;						\

    struct test_type##_tdata tdata;					\

									\

    printf("begin: %s\n", tcase->label);				\

									\

    xpthread_mutex_init (&sync, 0);					\

    xpthread_mutex_lock (&sync);					\

									\

    tdata.sync = &sync;							\

    tdata.tcase = tcase;						\

    tdata.ok = false;							\

									\

    pthread_t thr = xpthread_create (0, test_type##_threadproc,		\

				     (void *)&tdata);			\

    xpthread_cancel (thr);						\

    xpthread_mutex_unlock (&sync);					\

    void *rv = xpthread_join (thr);					\

									\

    xpthread_mutex_destroy (&sync);					\

									\

    bool ok = true;							\

    if (!check_stderr (tcase->expect_errmsg, stderr_trapped))		\

      {									\

	ok = false;							\

	printf("FAIL: %s: stderr not as expected\n", tcase->label);	\

      }									\

    if (!tdata.ok)							\

      {									\

	ok = false;							\

	printf("FAIL: %s: did not complete loop\n", tcase->label);	\

      }									\

    if (rv != PTHREAD_CANCELED)						\

      {									\

	ok = false;							\

	printf("FAIL: %s: thread was not cancelled\n", tcase->label);	\

      }									\

    if (ok)								\

      printf ("pass: %s\n", tcase->label);				\

    return ok;								\

  }

DEFINE_TEST_DRIVER (test_short,

		    getopt (tc->argc, (char *const *)tc->argv, tc->opts))

DEFINE_TEST_DRIVER (test_long,

		    getopt_long (tc->argc, (char *const *)tc->argv,

				 tc->opts, tc->longopts, 0))

/* Caution: all option strings must begin with a '+' or '-' so that

   getopt does not attempt to permute the argument vector (which is in

   read-only memory).  */

const struct test_short tests_short[] = {

  { "no errors",

    "+ab:c", { "program", "-ac", "-b", "x", 0 }, 4, false },

  { "invalid option",

    "+ab:c", { "program", "-d", 0 },		 2, true },

  { "missing argument",

    "+ab:c", { "program", "-b", 0 },		 2, true },

  { 0 }

};

const struct test_long tests_long[] = {

  { "no errors (long)",

    "+ab:c", { { "alpha",   no_argument,       0, 'a' },

	       { "bravo",   required_argument, 0, 'b' },

	       { "charlie", no_argument,       0, 'c' },

	       { 0 } },

    { "program", "-a", "--charlie", "--bravo=x", 0 }, 4, false },

  { "invalid option (long)",

    "+ab:c", { { "alpha",   no_argument,       0, 'a' },

	       { "bravo",   required_argument, 0, 'b' },

	       { "charlie", no_argument,       0, 'c' },

	       { 0 } },

    { "program", "-a", "--charlie", "--dingo", 0 }, 4, true },

  { "unwanted argument",

    "+ab:c", { { "alpha",   no_argument,       0, 'a' },

	       { "bravo",   required_argument, 0, 'b' },

	       { "charlie", no_argument,       0, 'c' },

	       { 0 } },

    { "program", "-a", "--charlie=dingo", "--bravo=x", 0 }, 4, true },

  { "missing argument",

    "+ab:c", { { "alpha",   no_argument,       0, 'a' },

	       { "bravo",   required_argument, 0, 'b' },

	       { "charlie", no_argument,       0, 'c' },

	       { 0 } },

    { "program", "-a", "--charlie", "--bravo", 0 }, 4, true },

  { "ambiguous options",

    "+uvw", { { "veni", no_argument, 0, 'u' },

	      { "vedi", no_argument, 0, 'v' },

	      { "veci", no_argument, 0, 'w' } },

    { "program", "--ve", 0 }, 2, true },

  { "no errors (long W)",

    "+ab:cW;", { { "alpha",   no_argument,	 0, 'a' },

		 { "bravo",   required_argument, 0, 'b' },

		 { "charlie", no_argument,	 0, 'c' },

		 { 0 } },

    { "program", "-a", "-W", "charlie", "-W", "bravo=x", 0 }, 6, false },

  { "missing argument (W itself)",

    "+ab:cW;", { { "alpha",   no_argument,	 0, 'a' },

		 { "bravo",   required_argument, 0, 'b' },

		 { "charlie", no_argument,	 0, 'c' },

		 { 0 } },

    { "program", "-a", "-W", "charlie", "-W", 0 }, 5, true },

  { "missing argument (W longopt)",

    "+ab:cW;", { { "alpha",   no_argument,	 0, 'a' },

		 { "bravo",   required_argument, 0, 'b' },

		 { "charlie", no_argument,	 0, 'c' },

		 { 0 } },

    { "program", "-a", "-W", "charlie", "-W", "bravo", 0 }, 6, true },

  { "unwanted argument (W longopt)",

    "+ab:cW;", { { "alpha",   no_argument,	 0, 'a' },

		 { "bravo",   required_argument, 0, 'b' },

		 { "charlie", no_argument,	 0, 'c' },

		 { 0 } },

    { "program", "-a", "-W", "charlie=dingo", "-W", "bravo=x", 0 }, 6, true },

  { "ambiguous options (W)",

    "+uvwW;", { { "veni", no_argument, 0, 'u' },

		{ "vedi", no_argument, 0, 'v' },

		{ "veci", no_argument, 0, 'w' } },

    { "program", "-W", "ve", 0 }, 3, true },

  { 0 }

};

static int

do_test (void)

{

  int stderr_trap = create_temp_file ("stderr", 0);

  if (stderr_trap < 0)

    {

      perror ("create_temp_file");

      return 1;

    }

  FILE *stderr_trapped = fdopen(stderr_trap, "r+");

  if (!stderr_trapped)

    {

      perror ("fdopen");

      return 1;

    }

  int old_stderr = dup (fileno (stderr));

  if (old_stderr < 0)

    {

      perror ("dup");

      return 1;

    }

  if (dup2 (stderr_trap, 2) < 0)

    {

      perror ("dup2");

      return 1;

    }

  rewind (stderr);

  bool success = true;

  for (const struct test_short *tcase = tests_short; tcase->label; tcase++)

    success = do_test_short (tcase, stderr_trapped) && success;

  for (const struct test_long *tcase = tests_long; tcase->label; tcase++)

    success = do_test_long (tcase, stderr_trapped) && success;

  dup2 (old_stderr, 2);

  close (old_stderr);

  fclose (stderr_trapped);

  return success ? 0 : 1;

}

#include <support/test-driver.c>