git.m6w6.name Git - m6w6/libmemcached/blob - libtest/unittest.cc

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  libtest
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *
   7  *  This library is free software; you can redistribute it and/or
   8  *  modify it under the terms of the GNU Lesser General Public
   9  *  License as published by the Free Software Foundation; either
  10  *  version 3 of the License, or (at your option) any later version.
  11  *
  12  *  This library is distributed in the hope that it will be useful,
  13  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  Lesser General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU Lesser General Public
  18  *  License along with this library; if not, write to the Free Software
  19  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
  20  */
  21
  22
  23 #include <config.h>
  24
  25 #include <libtest/test.hpp>
  26
  27 #include <cstdlib>
  28 #include <unistd.h>
  29
  30 using namespace libtest;
  31
  32 static test_return_t LIBTOOL_COMMAND_test(void *)
  33 {
  34   test_true(getenv("LIBTOOL_COMMAND"));
  35   return TEST_SUCCESS;
  36 }
  37
  38 static test_return_t VALGRIND_COMMAND_test(void *)
  39 {
  40   test_true(getenv("VALGRIND_COMMAND"));
  41   return TEST_SUCCESS;
  42 }
  43
  44 static test_return_t HELGRIND_COMMAND_test(void *)
  45 {
  46   test_true(getenv("HELGRIND_COMMAND"));
  47   return TEST_SUCCESS;
  48 }
  49
  50 static test_return_t GDB_COMMAND_test(void *)
  51 {
  52   test_true(getenv("GDB_COMMAND"));
  53   return TEST_SUCCESS;
  54 }
  55
  56 static test_return_t test_success_test(void *)
  57 {
  58   return TEST_SUCCESS;
  59 }
  60
  61 static test_return_t test_failure_test(void *)
  62 {
  63   return TEST_SKIPPED; // Only run this when debugging
  64
  65   test_compare(1, 2);
  66   return TEST_SUCCESS;
  67 }
  68
  69 static test_return_t local_test(void *)
  70 {
  71   if (getenv("LIBTEST_LOCAL"))
  72   {
  73     test_true(test_is_local());
  74   }
  75   else
  76   {
  77     test_false(test_is_local());
  78   }
  79
  80   return TEST_SUCCESS;
  81 }
  82
  83 static test_return_t local_not_test(void *)
  84 {
  85   return TEST_SKIPPED;
  86
  87   std::string temp;
  88
  89   const char *ptr;
  90   if ((ptr= getenv("LIBTEST_LOCAL")) == NULL)
  91   {
  92     temp.append(ptr);
  93   }
  94
  95   // unsetenv() will cause issues with valgrind
  96   _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"));
  97   test_compare(0, unsetenv("LIBTEST_LOCAL"));
  98   test_false(test_is_local());
  99
 100   test_compare(0, setenv("LIBTEST_LOCAL", "1", 1));
 101   test_true(test_is_local());
 102
 103   if (temp.empty())
 104   {
 105     test_compare(0, unsetenv("LIBTEST_LOCAL"));
 106   }
 107   else
 108   {
 109     char *old_string= strdup(temp.c_str());
 110     test_compare(0, setenv("LIBTEST_LOCAL", old_string, 1));
 111   }
 112
 113   return TEST_SUCCESS;
 114 }
 115
 116 static test_return_t var_exists_test(void *)
 117 {
 118   test_compare(0, access("var", R_OK | W_OK | X_OK));
 119   return TEST_SUCCESS;
 120 }
 121
 122 static test_return_t var_tmp_exists_test(void *)
 123 {
 124   test_compare(0, access("var/tmp", R_OK | W_OK | X_OK));
 125   return TEST_SUCCESS;
 126 }
 127
 128 static test_return_t var_run_exists_test(void *)
 129 {
 130   test_compare(0, access("var/run", R_OK | W_OK | X_OK));
 131   return TEST_SUCCESS;
 132 }
 133
 134 static test_return_t var_log_exists_test(void *)
 135 {
 136   test_compare(0, access("var/log", R_OK | W_OK | X_OK));
 137   return TEST_SUCCESS;
 138 }
 139
 140 static test_return_t var_tmp_test(void *)
 141 {
 142   FILE *file= fopen("var/tmp/junk", "w+");
 143   test_true(file);
 144   fclose(file);
 145   return TEST_SUCCESS;
 146 }
 147
 148 static test_return_t var_run_test(void *)
 149 {
 150   FILE *file= fopen("var/run/junk", "w+");
 151   test_true(file);
 152   fclose(file);
 153   return TEST_SUCCESS;
 154 }
 155
 156 static test_return_t var_log_test(void *)
 157 {
 158   FILE *file= fopen("var/log/junk", "w+");
 159   test_true(file);
 160   fclose(file);
 161   return TEST_SUCCESS;
 162 }
 163
 164 static test_return_t var_tmp_rm_test(void *)
 165 {
 166   test_true(unlink("var/tmp/junk") == 0);
 167   return TEST_SUCCESS;
 168 }
 169
 170 static test_return_t var_run_rm_test(void *)
 171 {
 172   test_true(unlink("var/run/junk") == 0);
 173   return TEST_SUCCESS;
 174 }
 175
 176 static test_return_t var_log_rm_test(void *)
 177 {
 178   test_true(unlink("var/log/junk") == 0);
 179   return TEST_SUCCESS;
 180 }
 181
 182
 183 #if 0
 184 static test_return_t pause_test(void *)
 185 {
 186   (void)getchar();
 187   return TEST_SUCCESS;
 188 }
 189 #endif
 190
 191
 192 static test_return_t gearmand_cycle_test(void *object)
 193 {
 194   server_startup_st *servers= (server_startup_st*)object;
 195   test_true(servers);
 196
 197   if (HAVE_LIBGEARMAN)
 198   {
 199     const char *argv[1]= { "cycle_gearmand" };
 200     test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
 201
 202     return TEST_SUCCESS;
 203   }
 204
 205   return TEST_SKIPPED;
 206 }
 207
 208 static test_return_t memcached_cycle_test(void *object)
 209 {
 210   server_startup_st *servers= (server_startup_st*)object;
 211   test_true(servers);
 212
 213   if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
 214   {
 215     const char *argv[1]= { "cycle_memcached" };
 216     test_true(server_startup(*servers, "memcached", 9998, 1, argv));
 217
 218     return TEST_SUCCESS;
 219   }
 220
 221   return TEST_SKIPPED;
 222 }
 223
 224 static test_return_t memcached_socket_cycle_test(void *object)
 225 {
 226   server_startup_st *servers= (server_startup_st*)object;
 227   test_true(servers);
 228
 229   if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
 230   {
 231     const char *argv[1]= { "cycle_memcached" };
 232     test_true(servers->start_socket_server("memcached", 9997, 1, argv));
 233
 234     return TEST_SUCCESS;
 235   }
 236
 237   return TEST_SKIPPED;
 238 }
 239
 240 test_st gearmand_tests[] ={
 241 #if 0
 242   {"pause", 0, pause_test },
 243 #endif
 244   {"gearmand startup-shutdown", 0, gearmand_cycle_test },
 245   {0, 0, 0}
 246 };
 247
 248 test_st memcached_tests[] ={
 249   {"memcached startup-shutdown", 0, memcached_cycle_test },
 250   {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
 251   {0, 0, 0}
 252 };
 253
 254 test_st environment_tests[] ={
 255   {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
 256   {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
 257   {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
 258   {"GDB_COMMAND", 0, GDB_COMMAND_test },
 259   {0, 0, 0}
 260 };
 261
 262 test_st tests_log[] ={
 263   {"TEST_SUCCESS", 0, test_success_test },
 264   {"TEST_FAILURE", 0, test_failure_test },
 265   {0, 0, 0}
 266 };
 267
 268 test_st local_log[] ={
 269   {"test_is_local()", 0, local_test },
 270   {"test_is_local(NOT)", 0, local_not_test },
 271   {0, 0, 0}
 272 };
 273
 274 test_st directories_tests[] ={
 275   {"var exists", 0, var_exists_test },
 276   {"var/tmp exists", 0, var_tmp_exists_test },
 277   {"var/run exists", 0, var_run_exists_test },
 278   {"var/log exists", 0, var_log_exists_test },
 279   {"var/tmp", 0, var_tmp_test },
 280   {"var/run", 0, var_run_test },
 281   {"var/log", 0, var_log_test },
 282   {"var/tmp rm", 0, var_tmp_rm_test },
 283   {"var/run rm", 0, var_run_rm_test },
 284   {"var/log rm", 0, var_log_rm_test },
 285   {0, 0, 0}
 286 };
 287
 288 collection_st collection[] ={
 289   {"environment", 0, 0, environment_tests},
 290   {"return values", 0, 0, tests_log},
 291   {"local", 0, 0, local_log},
 292   {"directories", 0, 0, directories_tests},
 293   {"gearmand", 0, 0, gearmand_tests},
 294   {"memcached", 0, 0, memcached_tests},
 295   {0, 0, 0, 0}
 296 };
 297
 298 static void *world_create(server_startup_st& servers, test_return_t&)
 299 {
 300   return &servers;
 301 }
 302
 303 void get_world(Framework *world)
 304 {
 305   world->collections= collection;
 306   world->_create= world_create;
 307 }