Merge lp:~vjsamuel/drizzle/refactor-drizzletest into lp:~drizzle-trunk/drizzle/development

[Vijay Samuel]

=== modified file 'client/drizzle.cc'
--- client/drizzle.cc	2010-06-09 21:36:07 +0000
+++ client/drizzle.cc	2010-06-16 07:57:30 +0000
@@ -1531,7 +1531,7 @@
   po::variables_map vm;
 
   po::positional_options_description p;
-  p.add("database", -1);
+  p.add("database", 1);
 
   po::store(po::command_line_parser(argc, argv).options(long_options).
             positional(p).extra_parser(parse_password_arg).run(), vm);
 
=== modified file 'client/drizzletest.cc'
--- client/drizzletest.cc	2010-06-03 07:59:07 +0000
+++ client/drizzletest.cc	2010-06-16 07:57:30 +0000
@@ -44,6 +44,7 @@
 #include <map>
 #include <string>
 #include <sstream>
+#include <fstream>
 #include <iostream>
 #include <vector>
 #include <algorithm>
@@ -54,6 +55,7 @@
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
+#include <boost/program_options.hpp>
 
 #include PCRE_HEADER
 
@@ -66,11 +68,12 @@
 #include "drizzled/gettext.h"
 #include "drizzled/drizzle_time.h"
 #include "drizzled/charset.h"
+#include <drizzled/configmake.h>
 
 #ifndef DRIZZLE_RETURN_SERVER_GONE
 #define DRIZZLE_RETURN_HANDSHAKE_FAILED DRIZZLE_RETURN_ERROR_CODE
 #endif
-
+namespace po= boost::program_options;
 using namespace std;
 using namespace drizzled;
 
@@ -95,14 +98,10 @@
 };
 
 static int record= 0, opt_sleep= -1;
-static char *opt_db= NULL, *opt_pass= NULL;
-const char *opt_user= NULL, *opt_host= NULL, *unix_sock= NULL,
-           *opt_basedir= "./";
-const char *opt_logdir= "";
-const char *opt_include= NULL, *opt_charsets_dir;
-const char *opt_testdir= NULL;
+static char *opt_pass= NULL;
+const char *unix_sock= NULL;
 static uint32_t opt_port= 0;
-static int opt_max_connect_retries;
+static uint32_t opt_max_connect_retries;
 static bool silent= false, verbose= false;
 static bool tty_password= false;
 static bool opt_mark_progress= false;
@@ -116,10 +115,21 @@
 static bool server_initialized= false;
 static bool is_windows= false;
 static bool opt_mysql= false;
-static char **default_argv;
-static const char *load_default_groups[]= { "drizzletest", "client", 0 };
+const string PASSWORD_SENTINEL("\0\0\0\0\0", 5);
 static char line_buffer[MAX_DELIMITER_LENGTH], *line_buffer_pos= line_buffer;
 
+std::string opt_basedir,
+  opt_charsets_dir,
+  opt_db,
+  opt_host,
+  opt_include,
+  opt_testdir,
+  opt_logdir,
+  password,
+  opt_password,
+  result_file_name,
+  opt_user;
+
 static uint32_t start_lineno= 0; /* Start line of current command */
 
 /* Number of lines of the result to include in failure report */
@@ -189,7 +199,6 @@
 master_pos_st master_pos;
 
 /* if set, all results are concated and compared against this file */
-const char *result_file_name= NULL;
 
 typedef struct st_var
 {
@@ -920,7 +929,6 @@
 
   free_all_replace();
   free(opt_pass);
-  internal::free_defaults(default_argv);
 
   return;
 }
@@ -1002,11 +1010,11 @@
   }
 
   /* Dump the result that has been accumulated so far to .log file */
-  if (result_file_name && ds_res.length())
+  if (! result_file_name.empty() && ds_res.length())
     dump_result_to_log_file(ds_res.c_str(), ds_res.length());
 
   /* Dump warning messages */
-  if (result_file_name && ds_warning_messages.length())
+  if (! result_file_name.empty() && ds_warning_messages.length())
     dump_warning_messages();
 
   /*
@@ -1354,7 +1362,7 @@
   if ((fd2= internal::my_open(fname, O_RDONLY, MYF(0))) < 0)
   {
     internal::my_close(fd, MYF(0));
-    if (opt_testdir != NULL)
+    if (! opt_testdir.empty())
     {
       tmpfile= opt_testdir;
       if (tmpfile[tmpfile.length()] != '/')
@@ -1494,12 +1502,12 @@
   const char* mess= "Result content mismatch\n";
 
 
-  assert(result_file_name);
-
-  if (access(result_file_name, F_OK) != 0)
-    die("The specified result file does not exist: '%s'", result_file_name);
-
-  switch (string_cmp(ds, result_file_name)) {
+  assert(result_file_name.c_str());
+
+  if (access(result_file_name.c_str(), F_OK) != 0)
+    die("The specified result file does not exist: '%s'", result_file_name.c_str());
+
+  switch (string_cmp(ds, result_file_name.c_str())) {
   case RESULT_OK:
     break; /* ok */
   case RESULT_LENGTH_MISMATCH:
@@ -1513,25 +1521,25 @@
     */
     char reject_file[FN_REFLEN];
     size_t reject_length;
-    internal::dirname_part(reject_file, result_file_name, &reject_length);
+    internal::dirname_part(reject_file, result_file_name.c_str(), &reject_length);
 
     if (access(reject_file, W_OK) == 0)
     {
       /* Result file directory is writable, save reject file there */
-      internal::fn_format(reject_file, result_file_name, NULL,
+      internal::fn_format(reject_file, result_file_name.c_str(), NULL,
                 ".reject", MY_REPLACE_EXT);
     }
     else
     {
       /* Put reject file in opt_logdir */
-      internal::fn_format(reject_file, result_file_name, opt_logdir,
+      internal::fn_format(reject_file, result_file_name.c_str(), opt_logdir.c_str(),
                 ".reject", MY_REPLACE_DIR | MY_REPLACE_EXT);
     }
     str_to_file(reject_file, ds->c_str(), ds->length());
 
     ds->erase(); /* Don't create a .log file */
 
-    show_diff(NULL, result_file_name, reject_file);
+    show_diff(NULL, result_file_name.c_str(), reject_file);
     die("%s",mess);
     break;
   }
@@ -2147,7 +2155,7 @@
 
   if (!internal::test_if_hard_path(name))
   {
-    snprintf(buff, sizeof(buff), "%s%s",opt_basedir,name);
+    snprintf(buff, sizeof(buff), "%s%s",opt_basedir.c_str(),name);
     name=buff;
   }
   internal::fn_format(buff, name, "", "", MY_UNPACK_FILENAME);
@@ -2201,7 +2209,7 @@
     ; /* Do nothing */
   else
   {
-    if (opt_testdir != NULL)
+    if (! opt_testdir.empty())
     {
       string testdir(opt_testdir);
       if (testdir[testdir.length()] != '/')
@@ -3348,7 +3356,7 @@
   if (*p)
     *p++= 0;
   command->last_argument= p;
-  if (opt_testdir != NULL)
+  if (! opt_testdir.empty())
   {
     dest= opt_testdir;
     if (dest[dest.length()] != '/')
@@ -3685,16 +3693,16 @@
 */
 
 static void safe_connect(drizzle_con_st *con, const char *name,
-                         const char *host, const char *user, const char *pass,
-                         const char *db, int port)
+                         const string host, const string user, const char *pass,
+                         const string db, uint32_t port)
 {
-  int failed_attempts= 0;
+  uint32_t failed_attempts= 0;
   static uint32_t connection_retry_sleep= 100000; /* Microseconds */
   drizzle_return_t ret;
 
-  drizzle_con_set_tcp(con, host, port);
-  drizzle_con_set_auth(con, user, pass);
-  drizzle_con_set_db(con, db);
+  drizzle_con_set_tcp(con, host.c_str(), port);
+  drizzle_con_set_auth(con, user.c_str(), pass);
+  drizzle_con_set_db(con, db.c_str());
   while((ret= drizzle_con_connect(con)) != DRIZZLE_RETURN_OK)
   {
     /*
@@ -3836,7 +3844,7 @@
 
 static void do_connect(struct st_command *command)
 {
-  int con_port= opt_port;
+  uint32_t con_port= opt_port;
   const char *con_options;
   bool con_ssl= 0, con_compress= 0;
   struct st_connection* con_slot;
@@ -4496,8 +4504,6 @@
   return;
 }
 
-
-
 /*
   Create a command from a set of lines
 
@@ -4577,217 +4583,6 @@
   return(0);
 }
 
-
-static struct option my_long_options[] =
-{
-  {"help", '?', "Display this help and exit.", 0, 0, 0, GET_NO_ARG, NO_ARG,
-   0, 0, 0, 0, 0, 0},
-  {"basedir", 'b', "Basedir for tests.", (char**) &opt_basedir,
-   (char**) &opt_basedir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"character-sets-dir", OPT_CHARSETS_DIR,
-   "Directory where character sets are.", (char**) &opt_charsets_dir,
-   (char**) &opt_charsets_dir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"database", 'D', "Database to use.", (char**) &opt_db, (char**) &opt_db, 0,
-   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"host", 'h', "Connect to host.", (char**) &opt_host, (char**) &opt_host, 0,
-   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"include", 'i', "Include SQL before each test case.", (char**) &opt_include,
-   (char**) &opt_include, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"testdir", OPT_TESTDIR, "Path to use to search for test files",
-   (char**) &opt_testdir,
-   (char**) &opt_testdir, 0,GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"logdir", OPT_LOG_DIR, "Directory for log files", (char**) &opt_logdir,
-   (char**) &opt_logdir, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"mark-progress", OPT_MARK_PROGRESS,
-   "Write linenumber and elapsed time to <testname>.progress ",
-   (char**) &opt_mark_progress, (char**) &opt_mark_progress, 0,
-   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"max-connect-retries", OPT_MAX_CONNECT_RETRIES,
-   "Max number of connection attempts when connecting to server",
-   (char**) &opt_max_connect_retries, (char**) &opt_max_connect_retries, 0,
-   GET_INT, REQUIRED_ARG, 500, 1, 10000, 0, 0, 0},
-  {"mysql", 'm', N_("Use MySQL Protocol."),
-   (char**) &opt_mysql, (char**) &opt_mysql, 0, GET_BOOL, NO_ARG, 1, 0, 0,
-   0, 0, 0},
-  {"password", 'P', "Password to use when connecting to server.",
-   0, 0, 0, GET_STR, OPT_ARG, 0, 0, 0, 0, 0, 0},
-  {"port", 'p', "Port number to use for connection or 0 for default to, in "
-   "order of preference, drizzle.cnf, $DRIZZLE_TCP_PORT, "
-   "built-in default (" STRINGIFY_ARG(DRIZZLE_PORT) ").",
-   0, 0, 0, GET_UINT, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"quiet", 's', "Suppress all normal output.", (char**) &silent,
-   (char**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"record", 'r', "Record output of test_file into result file.",
-   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"result-file", 'R', "Read/Store result from/in this file.",
-   (char**) &result_file_name, (char**) &result_file_name, 0,
-   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"silent", 's', "Suppress all normal output. Synonym for --quiet.",
-   (char**) &silent, (char**) &silent, 0, GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"sleep", 'T', "Sleep always this many seconds on sleep commands.",
-   (char**) &opt_sleep, (char**) &opt_sleep, 0, GET_INT, REQUIRED_ARG, -1, -1, 0,
-   0, 0, 0},
-  {"tail-lines", OPT_TAIL_LINES,
-   "Number of lines of the resul to include in a failure report",
-   (char**) &opt_tail_lines, (char**) &opt_tail_lines, 0,
-   GET_INT, REQUIRED_ARG, 0, 0, 10000, 0, 0, 0},
-  {"test-file", 'x', "Read test from/in this file (default stdin).",
-   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"timer-file", 'm', "File where the timing in micro seconds is stored.",
-   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"tmpdir", 't', "Temporary directory where sockets are put.",
-   0, 0, 0, GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"user", 'u', "User for login.", (char**) &opt_user, (char**) &opt_user, 0,
-   GET_STR, REQUIRED_ARG, 0, 0, 0, 0, 0, 0},
-  {"verbose", 'v', "Write more.", (char**) &verbose, (char**) &verbose, 0,
-   GET_BOOL, NO_ARG, 0, 0, 0, 0, 0, 0},
-  {"version", 'V', "Output version information and exit.",
-   0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0},
-  { 0, 0, 0, 0, 0, 0, GET_NO_ARG, NO_ARG, 0, 0, 0, 0, 0, 0}
-};
-
-
-static void print_version(void)
-{
-  printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",internal::my_progname,MTEST_VERSION,
-         drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
-}
-
-static void usage(void)
-{
-  print_version();
-  printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
-  printf("Drizzle version modified by Brian, Jay, Monty Taylor, PatG and Stewart\n");
-  printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
-  printf("Runs a test against the DRIZZLE server and compares output with a results file.\n\n");
-  printf("Usage: %s [OPTIONS] [database] < test_file\n", internal::my_progname);
-  my_print_help(my_long_options);
-  printf("  --no-defaults       Don't read default options from any options file.\n");
-  my_print_variables(my_long_options);
-}
-
-int get_one_option(int optid, const struct option *, char *argument)
-{
-  char *endchar= NULL;
-  uint64_t temp_drizzle_port= 0;
-
-  switch(optid) {
-  case 'r':
-    record = 1;
-    break;
-  case 'x':
-  {
-    char buff[FN_REFLEN];
-    if (!internal::test_if_hard_path(argument))
-    {
-      snprintf(buff, sizeof(buff), "%s%s",opt_basedir,argument);
-      argument= buff;
-    }
-    internal::fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
-    assert(cur_file == file_stack && cur_file->file == 0);
-    if (!(cur_file->file= fopen(buff, "r")))
-    {
-      fprintf(stderr, _("Could not open '%s' for reading: errno = %d"), buff, errno);
-      return EXIT_ARGUMENT_INVALID;
-    }
-    if (!(cur_file->file_name= strdup(buff)))
-    {
-      fprintf(stderr, _("Out of memory"));
-      return EXIT_OUT_OF_MEMORY;
-    }
-    cur_file->lineno= 1;
-    break;
-  }
-  case 'm':
-  {
-    static char buff[FN_REFLEN];
-    if (!internal::test_if_hard_path(argument))
-    {
-      snprintf(buff, sizeof(buff), "%s%s",opt_basedir,argument);
-      argument= buff;
-    }
-    internal::fn_format(buff, argument, "", "", MY_UNPACK_FILENAME);
-    timer_file= buff;
-    unlink(timer_file);       /* Ignore error, may not exist */
-    break;
-  }
-  case 'p':
-    temp_drizzle_port= (uint64_t) strtoul(argument, &endchar, 10);
-    /* if there is an alpha character this is not a valid port */
-    if (strlen(endchar) != 0)
-    {
-      fprintf(stderr, _("Non-integer value supplied for port.  If you are trying to enter a password please use --password instead.\n"));
-      return EXIT_ARGUMENT_INVALID;
-    }
-    /* If the port number is > 65535 it is not a valid port
-       This also helps with potential data loss casting unsigned long to a
-       uint32_t. */
-    if ((temp_drizzle_port == 0) || (temp_drizzle_port > 65535))
-    {
-      fprintf(stderr, _("Value supplied for port is not valid.\n"));
-      return EXIT_ARGUMENT_INVALID;
-    }
-    else
-    {
-      opt_port= (uint32_t) temp_drizzle_port;
-    }
-    break;
-  case 'P':
-    if (argument)
-    {
-      if (opt_pass)
-        free(opt_pass);
-      opt_pass = strdup(argument);
-      if (opt_pass == NULL)
-      {
-        fprintf(stderr, _("Out of memory"));
-        return EXIT_OUT_OF_MEMORY;
-      }
-      while (*argument)
-      {
-        /* Overwriting password with 'x' */
-        *argument++= 'x';
-      }
-      tty_password= 0;
-    }
-    else
-      tty_password= 1;
-    break;
-  case 't':
-    strncpy(TMPDIR, argument, sizeof(TMPDIR));
-    break;
-  case 'V':
-    print_version();
-    exit(0);
-  case '?':
-    usage();
-    exit(0);
-  }
-  return 0;
-}
-
-
-static int parse_args(int argc, char **argv)
-{
-  internal::load_defaults("drizzle",load_default_groups,&argc,&argv);
-  default_argv= argv;
-
-  if ((handle_options(&argc, &argv, my_long_options, get_one_option)))
-    exit(1);
-
-  if (argc > 1)
-  {
-    usage();
-    exit(1);
-  }
-  if (argc == 1)
-    opt_db= *argv;
-  if (tty_password)
-    opt_pass= client_get_tty_password(NULL);          /* purify tested */
-
-  return 0;
-}
-
 /*
   Write the content of str into file
 
@@ -4806,7 +4601,7 @@
   int flags= O_WRONLY | O_CREAT;
   if (!internal::test_if_hard_path(fname))
   {
-    snprintf(buff, sizeof(buff), "%s%s",opt_basedir,fname);
+    snprintf(buff, sizeof(buff), "%s%s",opt_basedir.c_str(),fname);
     fname= buff;
   }
   internal::fn_format(buff, fname, "", "", MY_UNPACK_FILENAME);
@@ -4842,8 +4637,8 @@
 void dump_result_to_log_file(const char *buf, int size)
 {
   char log_file[FN_REFLEN];
-  str_to_file(internal::fn_format(log_file, result_file_name, opt_logdir, ".log",
-                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
+  str_to_file(internal::fn_format(log_file, result_file_name.c_str(), opt_logdir.c_str(), ".log",
+                        ! opt_logdir.empty() ? MY_REPLACE_DIR | MY_REPLACE_EXT :
                         MY_REPLACE_EXT),
               buf, size);
   fprintf(stderr, "\nMore results from queries before failure can be found in %s\n",
@@ -4853,9 +4648,9 @@
 void dump_progress(void)
 {
   char progress_file[FN_REFLEN];
-  str_to_file(internal::fn_format(progress_file, result_file_name,
-                        opt_logdir, ".progress",
-                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
+  str_to_file(internal::fn_format(progress_file, result_file_name.c_str(),
+                        opt_logdir.c_str(), ".progress",
+                        ! opt_logdir.empty() ? MY_REPLACE_DIR | MY_REPLACE_EXT :
                         MY_REPLACE_EXT),
               ds_progress.c_str(), ds_progress.length());
 }
@@ -4864,8 +4659,8 @@
 {
   char warn_file[FN_REFLEN];
 
-  str_to_file(internal::fn_format(warn_file, result_file_name, opt_logdir, ".warnings",
-                        *opt_logdir ? MY_REPLACE_DIR | MY_REPLACE_EXT :
+  str_to_file(internal::fn_format(warn_file, result_file_name.c_str(), opt_logdir.c_str(), ".warnings",
+                        ! opt_logdir.empty() ? MY_REPLACE_DIR | MY_REPLACE_EXT :
                         MY_REPLACE_EXT),
               ds_warning_messages.c_str(), ds_warning_messages.length());
 }
@@ -5563,18 +5358,185 @@
 
 }
 
+static void check_retries(uint32_t in_opt_max_connect_retries)
+{
+  if (in_opt_max_connect_retries > 10000 || opt_max_connect_retries<1)
+  {
+    cout<<N_("Error: Invalid Value for opt_max_connect_retries"); 
+    exit(-1);
+  }
+  opt_max_connect_retries= in_opt_max_connect_retries;
+}
+
+static void check_tail_lines(uint32_t in_opt_tail_lines)
+{
+  if (in_opt_tail_lines > 10000)
+  {
+    cout<<N_("Error: Invalid Value for opt_tail_lines"); 
+    exit(-1);
+  }
+  opt_tail_lines= in_opt_tail_lines;
+}
+
+static void check_sleep(int32_t in_opt_sleep)
+{
+  if (in_opt_sleep < -1)
+  {
+    cout<<N_("Error: Invalid Value for opt_sleep"); 
+    exit(-1);
+  }
+  opt_sleep= in_opt_sleep;
+}
+
+static pair<string, string> parse_password_arg(std::string s)
+{
+  if (s.find("--password") == 0)
+  {
+    if (s == "--password")
+    {
+      tty_password= true;
+      //check if no argument is passed.
+      return make_pair("password", PASSWORD_SENTINEL);
+    }
+
+    if (s.substr(10,3) == "=\"\"" || s.substr(10,3) == "=''")
+    {
+      // Check if --password="" or --password=''
+      return make_pair("password", PASSWORD_SENTINEL);
+    }
+    
+    if(s.substr(10) == "=" && s.length() == 11)
+    {
+      // check if --password= and return a default value
+      return make_pair("password", PASSWORD_SENTINEL);
+    }
+
+    if(s.length()>12 && (s[10] == '"' || s[10] == '\''))
+    {
+      // check if --password has quotes, remove quotes and return the value
+      return make_pair("password", s.substr(11,s.length()-1));
+    }
+
+    // if all above are false, it implies that --password=value, return value.
+    return make_pair("password", s.substr(11));
+  }
+
+  else
+  {
+    return make_pair(string(""), string(""));
+  } 
+}
 
 int main(int argc, char **argv)
 {
+try
+{
   struct st_command *command;
   bool q_send_flag= 0, abort_flag= 0;
   uint32_t command_executed= 0, last_command_executed= 0;
   string save_file("");
   struct stat res_info;
-  MY_INIT(argv[0]);
 
   TMPDIR[0]= 0;
 
+  po::options_description commandline_options("Options used only in command line");
+  commandline_options.add_options()
+  ("help,?", "Display this help and exit.")
+  ("mark-progress", po::value<bool>(&opt_mark_progress)->default_value(false)->zero_tokens(),
+  "Write linenumber and elapsed time to <testname>.progress ")
+  ("sleep,T", po::value<int32_t>(&opt_sleep)->default_value(-1)->notifier(&check_sleep),
+  "Sleep always this many seconds on sleep commands.")
+  ("test-file,x", po::value<string>(),
+  "Read test from/in this file (default stdin).")
+  ("timer-file,f", po::value<string>(),
+  "File where the timing in micro seconds is stored.")
+  ("tmpdir,t", po::value<string>(),
+  "Temporary directory where sockets are put.")
+  ("verbose,v", po::value<bool>(&verbose)->default_value(false),
+  "Write more.")
+  ("version,V", "Output version information and exit.")
+  ("no-defaults", po::value<bool>()->default_value(false)->zero_tokens(),
+  "Configuration file defaults are not used if no-defaults is set")
+  ;
+
+  po::options_description test_options("Options specific to the drizzleimport");
+  test_options.add_options()
+  ("basedir,b", po::value<string>(&opt_basedir)->default_value(""),
+  "Basedir for tests.")
+  ("character-sets-dir", po::value<string>(&opt_charsets_dir)->default_value(""),
+  "Directory where character sets are.")
+  ("database,D", po::value<string>(&opt_db)->default_value(""),
+  "Database to use.")
+  ("include,i", po::value<string>(&opt_include)->default_value(""),
+  "Include SQL before each test case.")  
+  ("testdir", po::value<string>(&opt_testdir)->default_value(""),
+  "Path to use to search for test files")
+  ("logdir", po::value<string>(&opt_logdir)->default_value(""),
+  "Directory for log files")
+  ("max-connect-retries", po::value<uint32_t>(&opt_max_connect_retries)->default_value(500)->notifier(&check_retries),
+  "Max number of connection attempts when connecting to server")
+  ("quiet,s", po::value<bool>(&silent)->default_value(0)->zero_tokens(),
+  "Suppress all normal output.")
+  ("record,r", "Record output of test_file into result file.")
+  ("result-file,R", po::value<string>(&result_file_name)->default_value(""),
+  "Read/Store result from/in this file.")
+  ("silent,s", po::value<bool>(&silent)->default_value(false)->zero_tokens(),
+  "Suppress all normal output. Synonym for --quiet.")
+  ("tail-lines", po::value<uint32_t>(&opt_tail_lines)->default_value(0)->notifier(&check_tail_lines),
+  "Number of lines of the resul to include in a failure report")
+  ;
+
+  po::options_description client_options("Options specific to the client");
+  client_options.add_options()
+
+  ("host,h", po::value<string>(&opt_host)->default_value("localhost"),
+  "Connect to host.")
+  ("mysql,m", po::value<bool>(&opt_mysql)->default_value(true)->zero_tokens(),
+  N_("Use MySQL Protocol."))
+  ("password,P", po::value<string>(&password)->default_value("PASSWORD_SENTINEL"),
+  "Password to use when connecting to server.")
+  ("port,p", po::value<uint32_t>(&opt_port)->default_value(0),
+  "Port number to use for connection or 0 for default")
+  ("protocol", po::value<string>(),
+  "The protocol of connection (tcp,socket,pipe,memory).")
+  ("user,u", po::value<string>(&opt_user)->default_value(""),
+  "User for login.")
+  ;
+
+  po::positional_options_description p;
+  p.add("database", 1);
+
+  po::options_description long_options("Allowed Options");
+  long_options.add(commandline_options).add(test_options).add(client_options);
+
+  std::string system_config_dir_test(SYSCONFDIR); 
+  system_config_dir_test.append("/drizzle/drizzletest.cnf");
+
+  std::string system_config_dir_client(SYSCONFDIR); 
+  system_config_dir_client.append("/drizzle/client.cnf");
+
+  po::variables_map vm;
+
+  po::store(po::command_line_parser(argc, argv).options(long_options).
+            positional(p).extra_parser(parse_password_arg).run(), vm);
+
+  if (! vm["no-defaults"].as<bool>())
+  {
+    ifstream user_test_ifs("~/.drizzle/drizzletest.cnf");
+    po::store(parse_config_file(user_test_ifs, test_options), vm);
+ 
+    ifstream system_test_ifs(system_config_dir_test.c_str());
+    store(parse_config_file(system_test_ifs, test_options), vm);
+
+    ifstream user_client_ifs("~/.drizzle/client.cnf");
+    po::store(parse_config_file(user_client_ifs, client_options), vm);
+ 
+    ifstream system_client_ifs(system_config_dir_client.c_str());
+    po::store(parse_config_file(system_client_ifs, client_options), vm);
+  }
+
+  po::notify(vm);
+
   /* Init expected errors */
   memset(&saved_expected_errors, 0, sizeof(saved_expected_errors));
 
@@ -5611,7 +5573,120 @@
   ds_progress.reserve(2048);
   ds_warning_messages.reserve(2048);
 
-  parse_args(argc, argv);
+ 
+  if (vm.count("record"))
+  {
+    record = 1;
+  }
+
+  if (vm.count("test-file"))
+  {
+    string tmp= vm["test-file"].as<string>();
+    char buff[FN_REFLEN];
+    if (!internal::test_if_hard_path(tmp.c_str()))
+    {
+      snprintf(buff, sizeof(buff), "%s%s",opt_basedir.c_str(),tmp.c_str());
+      tmp= buff;
+    }
+    internal::fn_format(buff, tmp.c_str(), "", "", MY_UNPACK_FILENAME);
+    assert(cur_file == file_stack && cur_file->file == 0);
+    if (!(cur_file->file= fopen(buff, "r")))
+    {
+      fprintf(stderr, _("Could not open '%s' for reading: errno = %d"), buff, errno);
+      return EXIT_ARGUMENT_INVALID;
+    }
+    if (!(cur_file->file_name= strdup(buff)))
+    {
+      fprintf(stderr, _("Out of memory"));
+      return EXIT_OUT_OF_MEMORY;
+    }
+    cur_file->lineno= 1;
+  }
+
+  if (vm.count("timer-file"))
+  {
+    string tmp= vm["timer-file"].as<string>().c_str();
+    static char buff[FN_REFLEN];
+    if (!internal::test_if_hard_path(tmp.c_str()))
+    {
+      snprintf(buff, sizeof(buff), "%s%s",opt_basedir.c_str(),tmp.c_str());
+      tmp= buff;
+    }
+    internal::fn_format(buff, tmp.c_str(), "", "", MY_UNPACK_FILENAME);
+    timer_file= buff;
+    unlink(timer_file);       /* Ignore error, may not exist */
+  }
+
+  if (vm.count("port"))
+  {
+    /* If the port number is > 65535 it is not a valid port
+       This also helps with potential data loss casting unsigned long to a
+       uint32_t. */
+    if (opt_port > 65535)
+    {
+      fprintf(stderr, _("Value supplied for port is not valid.\n"));
+      exit(EXIT_ARGUMENT_INVALID);
+    }
+  }
+
+  if (vm.count("password"))
+  {
+    if (!opt_password.empty())
+      opt_password.erase();
+    if (password == PASSWORD_SENTINEL)
+    {
+      opt_password= "";
+    }
+    else
+    {
+      opt_password= password;
+      tty_password= false;
+    }
+    char *start= (char *)password.c_str();
+    char *temp_pass= (char *)password.c_str();
+    while (*temp_pass)
+    {
+        /* Overwriting password with 'x' */
+        *temp_pass++= 'x';
+    }
+    if (*start)
+    {
+      start[1]= 0;
+    }
+  }
+  else
+  {
+      tty_password= true;
+  }
+
+  if (vm.count("tmpdir"))
+  {
+    strncpy(TMPDIR, vm["tmpdir"].as<string>().c_str(), sizeof(TMPDIR));
+  }
+
+  if (vm.count("version"))
+  {
+    printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",internal::my_progname,MTEST_VERSION,
+    drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
+    exit(0);
+  }
+  
+  if (vm.count("help"))
+  {
+    printf("%s  Ver %s Distrib %s, for %s-%s (%s)\n",internal::my_progname,MTEST_VERSION,
+    drizzle_version(),HOST_VENDOR,HOST_OS,HOST_CPU);
+    printf("MySQL AB, by Sasha, Matt, Monty & Jani\n");
+    printf("Drizzle version modified by Brian, Jay, Monty Taylor, PatG and Stewart\n");
+    printf("This software comes with ABSOLUTELY NO WARRANTY\n\n");
+    printf("Runs a test against the DRIZZLE server and compares output with a results file.\n\n");
+    printf("Usage: %s [OPTIONS] [database] < test_file\n", internal::my_progname);
+    exit(0);
+  }
+
+  if (tty_password)
+  {
+    opt_pass= client_get_tty_password(NULL);          /* purify tested */
+  }
 
   server_initialized= 1;
   if (cur_file == file_stack && cur_file->file == 0)
@@ -5632,7 +5707,6 @@
 
   if (!(cur_con->name = strdup("default")))
     die("Out of memory");
-
   safe_connect(&cur_con->con, cur_con->name, opt_host, opt_user, opt_pass,
                opt_db, opt_port);
 
@@ -5649,9 +5723,9 @@
   /* Update $drizzleclient_get_server_version to that of current connection */
   var_set_drizzleclient_get_server_version(&cur_con->con);
 
-  if (opt_include)
+  if (! opt_include.empty())
   {
-    open_file(opt_include);
+    open_file(opt_include.c_str());
   }
 
   while (!read_command(&command) && !abort_flag)
@@ -5955,14 +6029,14 @@
   */
   if (ds_res.length())
   {
-    if (result_file_name)
+    if (! result_file_name.empty())
     {
       /* A result file has been specified */
 
       if (record)
       {
         /* Recording - dump the output from test to result file */
-        str_to_file(result_file_name, ds_res.c_str(), ds_res.length());
+        str_to_file(result_file_name.c_str(), ds_res.c_str(), ds_res.length());
       }
       else
       {
@@ -5985,7 +6059,7 @@
   }
 
   if (!command_executed &&
-      result_file_name && !stat(result_file_name, &res_info))
+      ! result_file_name.empty() && !stat(result_file_name.c_str(), &res_info))
   {
     /*
       my_stat() successful on result file. Check if we have not run a
@@ -5997,16 +6071,23 @@
     die("No queries executed but result file found!");
   }
 
-  if ( opt_mark_progress && result_file_name )
+  if ( opt_mark_progress && ! result_file_name.empty() )
     dump_progress();
 
   /* Dump warning messages */
-  if (result_file_name && ds_warning_messages.length())
+  if (! result_file_name.empty() && ds_warning_messages.length())
     dump_warning_messages();
 
   timer_output();
   /* Yes, if we got this far the test has suceeded! Sakila smiles */
   cleanup_and_exit(0);
+}
+
+  catch(exception &err)
+  {
+    cerr<<err.what()<<endl;
+  }
+
   return 0; /* Keep compiler happy too */
 }
 
 
=== modified file 'client/include.am'
--- client/include.am	2010-06-12 21:25:45 +0000
+++ client/include.am	2010-06-16 07:57:30 +0000
@@ -65,7 +65,7 @@
 client_drizzleslap_CXXFLAGS=	${CLIENT_CXXFLAGS}
 
 client_drizzletest_SOURCES=	client/drizzletest.cc client/errname.cc
-client_drizzletest_LDADD=	${CLIENT_LDADD} ${LIBPCRE}
+client_drizzletest_LDADD=	${CLIENT_LDADD} ${BOOST_LIBS} ${LIBPCRE} 
 client_drizzletest_CXXFLAGS=	${CLIENT_CXXFLAGS}