Logo Search packages:      
Sourcecode: libnih version File versions  Download package

test_command.c

/* libnih
 *
 * test_command.c - test suite for nih/command.c
 *
 * Copyright © 2009 Scott James Remnant <scott@netsplit.com>.
 * Copyright © 2009 Canonical Ltd.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2, as
 * published by the Free Software Foundation.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */

#include <nih/test.h>

#include <sys/types.h>
#include <sys/wait.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <nih/macros.h>
#include <nih/alloc.h>
#include <nih/string.h>
#include <nih/main.h>
#include <nih/option.h>
#include <nih/command.h>


static int dry_run = 0;
static int wobble = 0;

static int was_called = 0;
static NihCommand *last_command = NULL;
static char *last_arg0 = NULL;
static char *last_arg1 = NULL;

static int
my_action (NihCommand *command, char * const *args)
{
      was_called++;

      last_command = malloc (sizeof (NihCommand));
      memcpy (last_command, command, sizeof (NihCommand));

      if (args[0]) {
            last_arg0 = strdup (args[0]);
            if (args[1]) {
                  last_arg1 = strdup (args[1]);
            } else {
                  last_arg1 = NULL;
            }

            if (! strcmp (args[0], "fail"))
                  return -1;
      } else {
            last_arg0 = NULL;
            last_arg1 = NULL;
      }

      return 0;
}


static NihOption options[] = {
      { 'n', "dry-run", N_("simulate and output actions only"),
        NULL, NULL, &dry_run, NULL },

      NIH_OPTION_LAST
};

static NihOption wibble_options[] = {
      { 0, "wobble", N_("wobble file while wibbling"),
        NULL, NULL, &wobble, NULL },

      NIH_OPTION_LAST
};

static NihCommandGroup test_group1 = { "First test group" };
static NihCommandGroup test_group2 = { "Second test group" };
static NihCommand commands[] = {
      { "foo", NULL,
        N_("do something fooish"),
        NULL,
        &test_group1, NULL,
        my_action },

      { "bar", N_("FILE"),
        N_("do something barish to a file"),
        NULL,
        &test_group1, NULL,
        my_action },

      { "baz", NULL,
        N_("do something bazish"),
        NULL,
        &test_group2, NULL,
        my_action },

      { "wibble", N_("SRC DEST"),
        N_("wibble a file from one place to another"),
        N_("Takes the file from SRC, wibbles it until any loose pieces "
           "fall off, and until it reaches DEST.  SRC and DEST may not "
           "be the same location."),
        NULL,
        wibble_options,
        my_action },

      NIH_COMMAND_LAST
};

static NihCommand commands2[] = {
      { "really-overly-long-command-name", NULL,
        N_("does something irrelevant, and the synopsis is long enough to "
           "wrap across multiple lines"),
        NULL,
        NULL,
        NULL,
        NULL },

      { "hidden", NULL, NULL, NULL, NULL, NULL, NULL },

      NIH_COMMAND_LAST
};

void
test_parser (void)
{
      FILE *output;
      char *argv[16];
      int   argc, ret = 0;

      TEST_FUNCTION ("nih_command_parser");
      program_name = "test";
      output = tmpfile ();


      /* Check that the command parser calls the command function, and
       * when there are no arguments, just passes in a NULL array.
       */
      TEST_FEATURE ("with just command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "foo";
            argv[argc] = NULL;

            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "foo");
            TEST_EQ_P (last_arg0, NULL);

            free (last_command);
      }


      /* Check that a global option that appears before a command is
       * honoured.
       */
      TEST_FEATURE ("with global option followed by command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "-n";
            argv[argc++] = "foo";
            argv[argc] = NULL;

            dry_run = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (dry_run);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "foo");
            TEST_EQ_P (last_arg0, NULL);

            free (last_command);
      }


      /* Check that a global option that appears after a command is
       * still honoured, despite not being in the command's own options.
       */
      TEST_FEATURE ("with command followed by global option");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "foo";
            argv[argc++] = "-n";
            argv[argc] = NULL;

            dry_run = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (dry_run);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "foo");
            TEST_EQ_P (last_arg0, NULL);

            free (last_command);
      }


      /* Check that a command's own options are also honoured. */
      TEST_FEATURE ("with command followed by specific option");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "wibble";
            argv[argc++] = "--wobble";
            argv[argc] = NULL;

            wobble = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (wobble);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "wibble");
            TEST_EQ_P (last_arg0, NULL);

            free (last_command);
      }


      /* Check that global options and command-specific options can be
       * both given at once.
       */
      TEST_FEATURE ("with global option, command, then specific option");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "--dry-run";
            argv[argc++] = "wibble";
            argv[argc++] = "--wobble";
            argv[argc] = NULL;

            wobble = 0;
            dry_run = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (wobble);
            TEST_TRUE (dry_run);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "wibble");
            TEST_EQ_P (last_arg0, NULL);

            free (last_command);
      }


      /* Check that a double-dash terminator may appear before a command,
       * which only terminates the global options, not the command-specific
       * ones.
       */
      TEST_FEATURE ("with terminator before command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "--dry-run";
            argv[argc++] = "--";
            argv[argc++] = "wibble";
            argv[argc++] = "--wobble";
            argv[argc] = NULL;

            wobble = 0;
            dry_run = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (wobble);
            TEST_TRUE (dry_run);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "wibble");
            TEST_EQ_P (last_arg0, NULL);

            free (last_command);
      }


      /* Check that a double-dash terminator may appear after a command,
       * which terminates the option processing for that command as well.
       * Any option-like argument is passed to the function as an ordinary
       * argument in the array.
       */
      TEST_FEATURE ("with terminator before and after command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "--dry-run";
            argv[argc++] = "--";
            argv[argc++] = "wibble";
            argv[argc++] = "--";
            argv[argc++] = "--wobble";
            argv[argc] = NULL;

            wobble = 0;
            dry_run = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_FALSE (wobble);
            TEST_TRUE (dry_run);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "wibble");
            TEST_EQ_STR (last_arg0, "--wobble");
            TEST_EQ_P (last_arg1, NULL);

            free (last_arg0);
            free (last_command);
      }


      /* Check that non-option arguments may follow a command, they're
       * collected and passed to the function in a NULL-terminated array.
       */
      TEST_FEATURE ("with command and single argument");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "bar";
            argv[argc++] = "snarf";
            argv[argc] = NULL;

            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "bar");
            TEST_EQ_STR (last_arg0, "snarf");
            TEST_EQ_P (last_arg1, NULL);

            free (last_arg0);
            free (last_command);
      }


      /* Check that multiple arguments after the command are all passed
       * in the array.
       */
      TEST_FEATURE ("with command and multiple arguments");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "wibble";
            argv[argc++] = "snarf";
            argv[argc++] = "lick";
            argv[argc] = NULL;

            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "wibble");
            TEST_EQ_STR (last_arg0, "snarf");
            TEST_EQ_STR (last_arg1, "lick");

            free (last_arg0);
            free (last_arg1);
            free (last_command);
      }


      /* Check that an invalid global option appearing results in the
       * parser returning a negative number and outputting an error
       * message to stderr with a suggestion about help.
       */
      TEST_FEATURE ("with invalid global option before command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "-z";
            argv[argc++] = "foo";
            argv[argc] = NULL;

            was_called = 0;

            TEST_DIVERT_STDERR (output) {
                  ret = nih_command_parser (NULL, argc, argv,
                                      options, commands);
            }
            rewind (output);

            TEST_LT (ret, 0);
            TEST_FALSE (was_called);

            TEST_FILE_EQ (output, "test: invalid option: -z\n");
            TEST_FILE_EQ (output,
                        "Try `test --help' for more information.\n");
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that an invalid option appearing after the command also
       * results in the parser returning an error without running the
       * command function.
       */
      TEST_FEATURE ("with invalid option after command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "foo";
            argv[argc++] = "-z";
            argv[argc] = NULL;

            was_called = 0;

            TEST_DIVERT_STDERR (output) {
                  ret = nih_command_parser (NULL, argc, argv,
                                      options, commands);
            }
            rewind (output);

            TEST_LT (ret, 0);
            TEST_FALSE (was_called);

            TEST_FILE_EQ (output, "test: invalid option: -z\n");
            TEST_FILE_EQ (output, "Try `test --help' for more information.\n");
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that a missing command entirely results in the parser
       * terminating with an error and outputting a message.
       */
      TEST_FEATURE ("with missing command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc] = NULL;

            was_called = 0;

            TEST_DIVERT_STDERR (output) {
                  ret = nih_command_parser (NULL, argc, argv,
                                      options, commands);
            }
            rewind (output);

            TEST_LT (ret, 0);
            TEST_FALSE (was_called);

            TEST_FILE_EQ (output, "test: missing command\n");
            TEST_FILE_EQ (output,
                        "Try `test --help' for more information.\n");
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that an invalid command results in the parser returning
       * an error and outputting a message.
       */
      TEST_FEATURE ("with invalid command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "lick";
            argv[argc] = NULL;

            was_called = 0;

            TEST_DIVERT_STDERR (output) {
                  ret = nih_command_parser (NULL, argc, argv,
                                      options, commands);
            }
            rewind (output);

            TEST_LT (ret, 0);
            TEST_FALSE (was_called);

            TEST_FILE_EQ (output, "test: invalid command: lick\n");
            TEST_FILE_EQ (output,
                        "Try `test --help' for more information.\n");
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that the command may appear in the program name instead,
       * in which case all arguments are used including the first, and
       * all options considered to be both global and command options.
       */
      TEST_FEATURE ("with command in program name");
      TEST_ALLOC_FAIL {
            program_name = "wibble";

            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "snarf";
            argv[argc++] = "lick";
            argv[argc++] = "--wobble";
            argv[argc++] = "-n";
            argv[argc] = NULL;

            dry_run = 0;
            wobble = 0;
            was_called = 0;
            last_command = NULL;
            last_arg0 = NULL;
            last_arg1 = NULL;

            ret = nih_command_parser (NULL, argc, argv, options, commands);

            TEST_EQ (ret, 0);
            TEST_TRUE (dry_run);
            TEST_TRUE (wobble);
            TEST_TRUE (was_called);
            TEST_EQ_STR (last_command->command, "wibble");
            TEST_EQ_STR (last_arg0, "snarf");
            TEST_EQ_STR (last_arg1, "lick");

            free (last_arg0);
            free (last_arg1);
            free (last_command);
      }


      fclose (output);
}


void
test_help (void)
{
      FILE  *output;
      char  *argv[4];
      pid_t  pid;
      int    argc, status;

      TEST_FUNCTION ("nih_command_help");
      output = tmpfile ();

      /* Check that we can obtain a list of command using the "help"
       * command; which terminates the process with exit code 0.  The
       * output should be grouped according to the command group, and
       * each command indented with the text alongside and wrapped.
       */
      TEST_FEATURE ("with multiple groups");
      nih_main_init_full ("test", "wibble", "1.0",
                      "foo@bar.com", "Copyright Message");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "help";
            argv[argc] = NULL;

            TEST_CHILD (pid) {
                  unsetenv ("COLUMNS");

                  TEST_DIVERT_STDOUT (output) {
                        nih_command_parser (NULL, argc, argv,
                                        options, commands);
                        exit (1);
                  }
            }

            waitpid (pid, &status, 0);
            rewind (output);

            TEST_TRUE (WIFEXITED (status));
            TEST_EQ (WEXITSTATUS (status), 0);

            TEST_FILE_EQ (output, "First test group commands:\n");
            TEST_FILE_EQ (output, ("  foo                         "
                               "do something fooish\n"));
            TEST_FILE_EQ (output, ("  bar                         "
                               "do something barish to a file\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Second test group commands:\n");
            TEST_FILE_EQ (output, ("  baz                         "
                               "do something bazish\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Other commands:\n");
            TEST_FILE_EQ (output, ("  wibble                      "
                               "wibble a file from one place to "
                               "another\n"));
            TEST_FILE_EQ (output, ("  help                        "
                               "display list of commands\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, ("For more information on a command, "
                               "try `test COMMAND --help'.\n"));
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that if there's only a single group, the title is different;
       * also check that an overly long command name is wrapped properly,
       * synopsis is wrapped to multiple lines and a command without a
       * synopsis is not output at all.
       */
      TEST_FEATURE ("with single group and long name");
      nih_main_init_full ("test", "wibble", "1.0",
                      "foo@bar.com", "Copyright Message");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "help";
            argv[argc] = NULL;

            TEST_CHILD (pid) {
                  unsetenv ("COLUMNS");

                  TEST_DIVERT_STDOUT (output) {
                        nih_command_parser (NULL, argc, argv,
                                        options, commands2);
                        exit (1);
                  }
            }

            waitpid (pid, &status, 0);
            rewind (output);

            TEST_TRUE (WIFEXITED (status));
            TEST_EQ (WEXITSTATUS (status), 0);

            TEST_FILE_EQ (output, "Commands:\n");
            TEST_FILE_EQ (output, "  really-overly-long-command-name\n");
            TEST_FILE_EQ (output, ("                              "
                               "does something irrelevant, and the "
                               "synopsis is\n"));
            TEST_FILE_EQ (output, ("                                "
                               "long enough to wrap across multiple "
                               "lines\n"));
            TEST_FILE_EQ (output, ("  help                        "
                               "display list of commands\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, ("For more information on a command, "
                               "try `test COMMAND --help'.\n"));
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that the command functions sufficiently wrap the
       * nih_option_help function such that we can obtain help for the
       * program as a whole and get a message saying how to see the
       * commands list.
       */
      TEST_FUNCTION ("nih_option_help");

      TEST_FEATURE ("with no command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "--help";
            argv[argc] = NULL;

            nih_option_set_synopsis ("This is my program");
            nih_option_set_help ("Some help text");

            TEST_CHILD (pid) {
                  unsetenv ("COLUMNS");

                  TEST_DIVERT_STDOUT (output) {
                        nih_command_parser (NULL, argc, argv,
                                        options, commands);
                        exit (1);
                  }
            }

            waitpid (pid, &status, 0);
            rewind (output);

            TEST_TRUE (WIFEXITED (status));
            TEST_EQ (WEXITSTATUS (status), 0);

            TEST_FILE_EQ (output, ("Usage: test [OPTION]... "
                               "COMMAND [OPTION]... [ARG]...\n"));
            TEST_FILE_EQ (output, "This is my program\n");
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Options:\n");
            TEST_FILE_EQ (output, ("  -n, --dry-run               "
                               "simulate and output actions only\n"));
            TEST_FILE_EQ (output, ("  -q, --quiet                 "
                               "reduce output to errors only\n"));
            TEST_FILE_EQ (output, ("  -v, --verbose               "
                               "increase output to include "
                               "informational messages\n"));
            TEST_FILE_EQ (output, ("      --help                  "
                               "display this help and exit\n"));
            TEST_FILE_EQ (output, ("      --version               "
                               "output version information and "
                               "exit\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Some help text\n");
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, ("For a list of commands, "
                               "try `test help'.\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Report bugs to <foo@bar.com>\n");
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that the wrapping is sufficient that following a command
       * with the --help option outputs help for that option, including
       * the global options in the list.
       */
      TEST_FEATURE ("with a command");
      TEST_ALLOC_FAIL {
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "wibble";
            argv[argc++] = "--help";
            argv[argc] = NULL;

            TEST_CHILD (pid) {
                  unsetenv ("COLUMNS");

                  TEST_DIVERT_STDOUT (output) {
                        nih_command_parser (NULL, argc, argv,
                                        options, commands);
                        exit (1);
                  }
            }

            waitpid (pid, &status, 0);
            rewind (output);

            TEST_TRUE (WIFEXITED (status));
            TEST_EQ (WEXITSTATUS (status), 0);

            TEST_FILE_EQ (output, ("Usage: test wibble [OPTION]... "
                               "SRC DEST\n"));
            TEST_FILE_EQ (output, ("wibble a file from one place "
                               "to another\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Options:\n");
            TEST_FILE_EQ (output, ("      --wobble                "
                               "wobble file while wibbling\n"));
            TEST_FILE_EQ (output, ("  -n, --dry-run               "
                               "simulate and output actions only\n"));
            TEST_FILE_EQ (output, ("  -q, --quiet                 "
                               "reduce output to errors only\n"));
            TEST_FILE_EQ (output, ("  -v, --verbose               "
                               "increase output to include "
                               "informational messages\n"));
            TEST_FILE_EQ (output, ("      --help                  "
                               "display this help and exit\n"));
            TEST_FILE_EQ (output, ("      --version               "
                               "output version information "
                               "and exit\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, ("Takes the file from SRC, wibbles it "
                               "until any loose pieces fall off, and "
                               "until\n"));
            TEST_FILE_EQ (output, ("it reaches DEST.  SRC and DEST may "
                               "not be the same location.\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Report bugs to <foo@bar.com>\n");
            TEST_FILE_END (output);

            TEST_FILE_RESET (output);
      }


      /* Check that --help works if the program name itself is the name
       * of the command, it should behave as if the real binary were
       * called with the command as the first argument, except all of the
       * usage strings, etc. should make sense.
       */
      TEST_FEATURE ("with command in program_name");
      TEST_ALLOC_FAIL {
            program_name = "wibble";
            argc = 0;
            argv[argc++] = "ignored";
            argv[argc++] = "--help";
            argv[argc] = NULL;

            TEST_CHILD (pid) {
                  unsetenv ("COLUMNS");

                  TEST_DIVERT_STDOUT (output) {
                        nih_command_parser (NULL, argc, argv,
                                        options, commands);
                        exit (1);
                  }
            }

            waitpid (pid, &status, 0);
            rewind (output);

            TEST_TRUE (WIFEXITED (status));
            TEST_EQ (WEXITSTATUS (status), 0);

            TEST_FILE_EQ (output, "Usage: wibble [OPTION]... SRC DEST\n");
            TEST_FILE_EQ (output, ("wibble a file from one place to "
                               "another\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Options:\n");
            TEST_FILE_EQ (output, ("      --wobble                "
                               "wobble file while wibbling\n"));
            TEST_FILE_EQ (output, ("  -n, --dry-run               "
                               "simulate and output actions only\n"));
            TEST_FILE_EQ (output, ("  -q, --quiet                 "
                               "reduce output to errors only\n"));
            TEST_FILE_EQ (output, ("  -v, --verbose               "
                               "increase output to include "
                               "informational messages\n"));
            TEST_FILE_EQ (output, ("      --help                  "
                               "display this help and exit\n"));
            TEST_FILE_EQ (output, ("      --version               "
                               "output version information and "
                               "exit\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, ("Takes the file from SRC, wibbles it "
                               "until any loose pieces fall off, and "
                               "until\n"));
            TEST_FILE_EQ (output, ("it reaches DEST.  SRC and DEST may "
                               "not be the same location.\n"));
            TEST_FILE_EQ (output, "\n");
            TEST_FILE_EQ (output, "Report bugs to <foo@bar.com>\n");
            TEST_FILE_END (output);
      }

      fclose (output);
}


int
main (int   argc,
      char *argv[])
{
      test_parser ();
      test_help ();

      return 0;
}

Generated by  Doxygen 1.6.0   Back to index