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(const close_t& arg,
  70                        posix_spawn_file_actions_t& file_actions);
  71
  72     void nonblock();
  73     void cloexec();
  74     bool read(libtest::vchar_t&);
  75
  76   private:
  77     const int _std_fd;
  78     int _pipe_fd[2];
  79     bool _open[2];
  80   };
  81
  82 public:
  83   Application(const std::string& arg, const bool _use_libtool_arg= false);
  84
  85   virtual ~Application();
  86
  87   void add_option(const std::string&);
  88   void add_option(const std::string&, const std::string&);
  89   void add_long_option(const std::string& option_name, const std::string& option_value);
  90   error_t run(const char *args[]= NULL);
  91   error_t wait(bool nohang= true);
  92
  93   libtest::vchar_t stdout_result() const
  94   {
  95     return _stdout_buffer;
  96   }
  97
  98   size_t stdout_result_length() const
  99   {
 100     return _stdout_buffer.size();
 101   }
 102
 103   libtest::vchar_t stderr_result() const
 104   {
 105     return _stderr_buffer;
 106   }
 107
 108   const char* stderr_c_str() const
 109   {
 110     return &_stderr_buffer[0];
 111   }
 112
 113   size_t stderr_result_length() const
 114   {
 115     return _stderr_buffer.size();
 116   }
 117
 118   std::string print();
 119
 120   void use_valgrind(bool arg= true)
 121   {
 122     _use_valgrind= arg;
 123   }
 124
 125   bool check() const;
 126
 127   bool slurp();
 128   void murder();
 129
 130   void use_gdb(bool arg= true)
 131   {
 132     _use_gdb= arg;
 133   }
 134
 135   void use_ptrcheck(bool arg= true)
 136   {
 137     _use_ptrcheck= arg;
 138   }
 139
 140   std::string arguments();
 141
 142   std::string gdb_filename()
 143   {
 144     return  _gdb_filename;
 145   }
 146
 147   pid_t pid() const
 148   {
 149     return _pid;
 150   }
 151
 152   void will_fail()
 153   {
 154     _will_fail= true;
 155   }
 156
 157 private:
 158   void create_argv(const char *args[]);
 159   void delete_argv();
 160
 161 private:
 162   const bool _use_libtool;
 163   bool _use_valgrind;
 164   bool _use_gdb;
 165   bool _use_ptrcheck;
 166   bool _will_fail;
 167   size_t _argc;
 168   std::string _exectuble_name;
 169   std::string _exectuble;
 170   std::string _exectuble_with_path;
 171   std::string _gdb_filename;
 172   Options _options;
 173   Pipe stdin_fd;
 174   Pipe stdout_fd;
 175   Pipe stderr_fd;
 176   char * * built_argv;
 177   pid_t _pid;
 178   libtest::vchar_t _stdout_buffer;
 179   libtest::vchar_t _stderr_buffer;
 180 };
 181
 182 static inline std::ostream& operator<<(std::ostream& output, const enum Application::error_t &arg)
 183 {
 184   switch (arg)
 185   {
 186     case Application::SUCCESS:
 187       output << "EXIT_SUCCESS";
 188       break;
 189
 190     case Application::FAILURE:
 191       output << "EXIT_FAILURE";
 192       break;
 193
 194     case Application::INVALID:
 195       output << "127";
 196       break;
 197
 198     default:
 199       output << "EXIT_UNKNOWN";
 200   }
 201
 202   return output;
 203 }
 204
 205 int exec_cmdline(const std::string& executable, const char *args[], bool use_libtool= false);
 206
 207 const char *gearmand_binary();
 208 const char *drizzled_binary();
 209
 210 }