git.m6w6.name Git - m6w6/libmemcached/blob - libtest/cmdline.h

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Data Differential YATL (i.e. libtest)  library
   4  *
   5  *  Copyright (C) 2012 Data Differential, http://datadifferential.com/
   6  *
   7  *  Redistribution and use in source and binary forms, with or without
   8  *  modification, are permitted provided that the following conditions are
   9  *  met:
  10  *
  11  *      * Redistributions of source code must retain the above copyright
  12  *  notice, this list of conditions and the following disclaimer.
  13  *
  14  *      * Redistributions in binary form must reproduce the above
  15  *  copyright notice, this list of conditions and the following disclaimer
  16  *  in the documentation and/or other materials provided with the
  17  *  distribution.
  18  *
  19  *      * The names of its contributors may not be used to endorse or
  20  *  promote products derived from this software without specific prior
  21  *  written permission.
  22  *
  23  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  24  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  25  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  26  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  27  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  28  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  29  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  30  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  31  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  32  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  33  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  */
  36
  37 #pragma once
  38
  39 #include <spawn.h>
  40
  41 namespace libtest {
  42
  43 class Application {
  44 private:
  45   typedef std::vector< std::pair<std::string, std::string> > Options;
  46
  47 public:
  48
  49   enum error_t {
  50     SUCCESS= EXIT_SUCCESS,
  51     FAILURE= EXIT_FAILURE,
  52     INVALID= 127
  53   };
  54
  55   class Pipe {
  56   public:
  57     Pipe(int);
  58     ~Pipe();
  59
  60     int fd();
  61
  62     enum close_t {
  63       READ= 0,
  64       WRITE= 1
  65     };
  66
  67     void reset();
  68     void close(const close_t& arg);
  69     void dup_for_spawn(posix_spawn_file_actions_t& file_actions);
  70
  71     void nonblock();
  72     void cloexec();
  73     bool read(libtest::vchar_t&);
  74
  75   private:
  76     const int _std_fd;
  77     int _pipe_fd[2];
  78     bool _open[2];
  79   };
  80
  81 public:
  82   Application(const std::string& arg, const bool _use_libtool_arg= false);
  83
  84   virtual ~Application();
  85
  86   void add_option(const std::string&);
  87   void add_option(const std::string&, const std::string&);
  88   void add_long_option(const std::string& option_name, const std::string& option_value);
  89   error_t run(const char *args[]= NULL);
  90   error_t wait(bool nohang= true);
  91
  92   libtest::vchar_t stdout_result() const
  93   {
  94     return _stdout_buffer;
  95   }
  96
  97   size_t stdout_result_length() const
  98   {
  99     return _stdout_buffer.size();
 100   }
 101
 102   libtest::vchar_t stderr_result() const
 103   {
 104     return _stderr_buffer;
 105   }
 106
 107   const char* stderr_c_str() const
 108   {
 109     return &_stderr_buffer[0];
 110   }
 111
 112   size_t stderr_result_length() const
 113   {
 114     return _stderr_buffer.size();
 115   }
 116
 117   std::string print();
 118
 119   void use_valgrind(bool arg= true)
 120   {
 121     _use_valgrind= arg;
 122   }
 123
 124   bool check() const;
 125
 126   bool slurp();
 127   void murder();
 128
 129   void use_gdb(bool arg= true)
 130   {
 131     _use_gdb= arg;
 132   }
 133
 134   void use_ptrcheck(bool arg= true)
 135   {
 136     _use_ptrcheck= arg;
 137   }
 138
 139   std::string arguments();
 140
 141   std::string gdb_filename()
 142   {
 143     return  _gdb_filename;
 144   }
 145
 146   pid_t pid() const
 147   {
 148     return _pid;
 149   }
 150
 151   void will_fail()
 152   {
 153     _will_fail= true;
 154   }
 155
 156 private:
 157   void create_argv(const char *args[]);
 158   void delete_argv();
 159
 160 private:
 161   const bool _use_libtool;
 162   bool _use_valgrind;
 163   bool _use_gdb;
 164   bool _use_ptrcheck;
 165   bool _will_fail;
 166   size_t _argc;
 167   std::string _exectuble_name;
 168   std::string _exectuble;
 169   std::string _exectuble_with_path;
 170   std::string _gdb_filename;
 171   Options _options;
 172   Pipe stdin_fd;
 173   Pipe stdout_fd;
 174   Pipe stderr_fd;
 175   char * * built_argv;
 176   pid_t _pid;
 177   libtest::vchar_t _stdout_buffer;
 178   libtest::vchar_t _stderr_buffer;
 179 };
 180
 181 static inline std::ostream& operator<<(std::ostream& output, const enum Application::error_t &arg)
 182 {
 183   switch (arg)
 184   {
 185     case Application::SUCCESS:
 186       output << "EXIT_SUCCESS";
 187       break;
 188
 189     case Application::FAILURE:
 190       output << "EXIT_FAILURE";
 191       break;
 192
 193     case Application::INVALID:
 194       output << "127";
 195       break;
 196
 197     default:
 198       output << "EXIT_UNKNOWN";
 199   }
 200
 201   return output;
 202 }
 203
 204 int exec_cmdline(const std::string& executable, const char *args[], bool use_libtool= false);
 205
 206 const char *gearmand_binary();
 207 const char *drizzled_binary();
 208
 209 }