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 #if defined(LIBTEST_WITH_LIBMEMCACHED_SUPPORT) && LIBTEST_WITH_LIBMEMCACHED_SUPPORT
  28 #include <libmemcached/memcached.h>
  29 #endif
  30
  31 #if defined(LIBTEST_WITH_LIBGEARMAN_SUPPORT) && LIBTEST_WITH_LIBGEARMAN_SUPPORT
  32 #include <libgearman/gearman.h>
  33 #endif
  34
  35 #include <cstdlib>
  36 #include <unistd.h>
  37
  38 using namespace libtest;
  39
  40 static test_return_t LIBTOOL_COMMAND_test(void *)
  41 {
  42   test_true(getenv("LIBTOOL_COMMAND"));
  43   return TEST_SUCCESS;
  44 }
  45
  46 static test_return_t VALGRIND_COMMAND_test(void *)
  47 {
  48   test_true(getenv("VALGRIND_COMMAND"));
  49   return TEST_SUCCESS;
  50 }
  51
  52 static test_return_t HELGRIND_COMMAND_test(void *)
  53 {
  54   test_true(getenv("HELGRIND_COMMAND"));
  55   return TEST_SUCCESS;
  56 }
  57
  58 static test_return_t GDB_COMMAND_test(void *)
  59 {
  60   test_true(getenv("GDB_COMMAND"));
  61   return TEST_SUCCESS;
  62 }
  63
  64 static test_return_t test_success_equals_one_test(void *)
  65 {
  66   test_skip(HAVE_LIBMEMCACHED, true);
  67   test_zero(MEMCACHED_SUCCESS);
  68   return TEST_SUCCESS;
  69 }
  70
  71 static test_return_t test_success_test(void *)
  72 {
  73   return TEST_SUCCESS;
  74 }
  75
  76 static test_return_t test_failure_test(void *)
  77 {
  78   return TEST_SKIPPED; // Only run this when debugging
  79
  80   test_compare(1, 2);
  81   return TEST_SUCCESS;
  82 }
  83
  84 static test_return_t local_test(void *)
  85 {
  86   if (getenv("LIBTEST_LOCAL"))
  87   {
  88     test_true(test_is_local());
  89   }
  90   else
  91   {
  92     test_false(test_is_local());
  93   }
  94
  95   return TEST_SUCCESS;
  96 }
  97
  98 static test_return_t local_not_test(void *)
  99 {
 100   return TEST_SKIPPED;
 101
 102   std::string temp;
 103
 104   const char *ptr;
 105   if ((ptr= getenv("LIBTEST_LOCAL")) == NULL)
 106   {
 107     temp.append(ptr);
 108   }
 109
 110   // unsetenv() will cause issues with valgrind
 111   _compare(__FILE__, __LINE__, __func__, 0, unsetenv("LIBTEST_LOCAL"));
 112   test_compare(0, unsetenv("LIBTEST_LOCAL"));
 113   test_false(test_is_local());
 114
 115   test_compare(0, setenv("LIBTEST_LOCAL", "1", 1));
 116   test_true(test_is_local());
 117
 118   if (temp.empty())
 119   {
 120     test_compare(0, unsetenv("LIBTEST_LOCAL"));
 121   }
 122   else
 123   {
 124     char *old_string= strdup(temp.c_str());
 125     test_compare(0, setenv("LIBTEST_LOCAL", old_string, 1));
 126   }
 127
 128   return TEST_SUCCESS;
 129 }
 130
 131 static test_return_t var_exists_test(void *)
 132 {
 133   test_compare(0, access("var", R_OK | W_OK | X_OK));
 134   return TEST_SUCCESS;
 135 }
 136
 137 static test_return_t var_tmp_exists_test(void *)
 138 {
 139   test_compare(0, access("var/tmp", R_OK | W_OK | X_OK));
 140   return TEST_SUCCESS;
 141 }
 142
 143 static test_return_t var_run_exists_test(void *)
 144 {
 145   test_compare(0, access("var/run", R_OK | W_OK | X_OK));
 146   return TEST_SUCCESS;
 147 }
 148
 149 static test_return_t var_log_exists_test(void *)
 150 {
 151   test_compare(0, access("var/log", R_OK | W_OK | X_OK));
 152   return TEST_SUCCESS;
 153 }
 154
 155 static test_return_t var_tmp_test(void *)
 156 {
 157   FILE *file= fopen("var/tmp/junk", "w+");
 158   char buffer[1024];
 159   const char *dir= getcwd(buffer, sizeof(buffer));
 160   test_true_got(file, dir);
 161   fclose(file);
 162   return TEST_SUCCESS;
 163 }
 164
 165 static test_return_t var_run_test(void *)
 166 {
 167   FILE *file= fopen("var/run/junk", "w+");
 168   test_true(file);
 169   fclose(file);
 170   return TEST_SUCCESS;
 171 }
 172
 173 static test_return_t var_log_test(void *)
 174 {
 175   FILE *file= fopen("var/log/junk", "w+");
 176   test_true(file);
 177   fclose(file);
 178   return TEST_SUCCESS;
 179 }
 180
 181 static test_return_t var_tmp_rm_test(void *)
 182 {
 183   test_true(unlink("var/tmp/junk") == 0);
 184   return TEST_SUCCESS;
 185 }
 186
 187 static test_return_t var_run_rm_test(void *)
 188 {
 189   test_true(unlink("var/run/junk") == 0);
 190   return TEST_SUCCESS;
 191 }
 192
 193 static test_return_t var_log_rm_test(void *)
 194 {
 195   test_true(unlink("var/log/junk") == 0);
 196   return TEST_SUCCESS;
 197 }
 198
 199 static test_return_t _compare_test_return_t_test(void *)
 200 {
 201   test_compare(TEST_SUCCESS, TEST_SUCCESS);
 202
 203   return TEST_SUCCESS;
 204 }
 205
 206 static test_return_t _compare_memcached_return_t_test(void *)
 207 {
 208   test_skip(HAVE_LIBMEMCACHED, true);
 209   test_compare(MEMCACHED_SUCCESS, MEMCACHED_SUCCESS);
 210
 211   return TEST_SUCCESS;
 212 }
 213
 214 static test_return_t _compare_gearman_return_t_test(void *)
 215 {
 216   test_skip(HAVE_LIBGEARMAN, true);
 217
 218   return TEST_SUCCESS;
 219 }
 220
 221 static test_return_t gearmand_cycle_test(void *object)
 222 {
 223   server_startup_st *servers= (server_startup_st*)object;
 224   test_true(servers);
 225
 226   if (HAVE_LIBGEARMAN)
 227   {
 228     const char *argv[1]= { "cycle_gearmand" };
 229     test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
 230
 231     return TEST_SUCCESS;
 232   }
 233
 234   return TEST_SKIPPED;
 235 }
 236
 237 static test_return_t memcached_cycle_test(void *object)
 238 {
 239   server_startup_st *servers= (server_startup_st*)object;
 240   test_true(servers);
 241
 242   if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
 243   {
 244     const char *argv[1]= { "cycle_memcached" };
 245     test_true(server_startup(*servers, "memcached", 9998, 1, argv));
 246
 247     return TEST_SUCCESS;
 248   }
 249
 250   return TEST_SKIPPED;
 251 }
 252
 253 static test_return_t memcached_socket_cycle_test(void *object)
 254 {
 255   server_startup_st *servers= (server_startup_st*)object;
 256   test_true(servers);
 257
 258   if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
 259   {
 260     const char *argv[1]= { "cycle_memcached" };
 261     test_true(servers->start_socket_server("memcached", 9997, 1, argv));
 262
 263     return TEST_SUCCESS;
 264   }
 265
 266   return TEST_SKIPPED;
 267 }
 268
 269 static test_return_t memcached_sasl_test(void *object)
 270 {
 271   server_startup_st *servers= (server_startup_st*)object;
 272   test_true(servers);
 273
 274   if (getenv("TESTS_ENVIRONMENT"))
 275   {
 276     return TEST_SKIPPED;
 277   }
 278
 279   if (MEMCACHED_SASL_BINARY and HAVE_LIBMEMCACHED)
 280   {
 281     const char *argv[1]= { "cycle_memcached_sasl" };
 282     test_true(server_startup(*servers, "memcached-sasl", 9996, 1, argv));
 283
 284     return TEST_SUCCESS;
 285   }
 286
 287   return TEST_SKIPPED;
 288 }
 289
 290 test_st gearmand_tests[] ={
 291 #if 0
 292   {"pause", 0, pause_test },
 293 #endif
 294   {"gearmand startup-shutdown", 0, gearmand_cycle_test },
 295   {0, 0, 0}
 296 };
 297
 298 test_st memcached_tests[] ={
 299   {"memcached startup-shutdown", 0, memcached_cycle_test },
 300   {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
 301   {"memcached_sasl() startup-shutdown", 0, memcached_sasl_test },
 302   {0, 0, 0}
 303 };
 304
 305 test_st environment_tests[] ={
 306   {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
 307   {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
 308   {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
 309   {"GDB_COMMAND", 0, GDB_COMMAND_test },
 310   {0, 0, 0}
 311 };
 312
 313 test_st tests_log[] ={
 314   {"TEST_SUCCESS", false, test_success_test },
 315   {"TEST_FAILURE", false, test_failure_test },
 316   {"TEST_SUCCESS == 0", false, test_success_equals_one_test },
 317   {0, 0, 0}
 318 };
 319
 320 test_st local_log[] ={
 321   {"test_is_local()", 0, local_test },
 322   {"test_is_local(NOT)", 0, local_not_test },
 323   {0, 0, 0}
 324 };
 325
 326 test_st directories_tests[] ={
 327   {"var exists", 0, var_exists_test },
 328   {"var/tmp exists", 0, var_tmp_exists_test },
 329   {"var/run exists", 0, var_run_exists_test },
 330   {"var/log exists", 0, var_log_exists_test },
 331   {"var/tmp", 0, var_tmp_test },
 332   {"var/run", 0, var_run_test },
 333   {"var/log", 0, var_log_test },
 334   {"var/tmp rm", 0, var_tmp_rm_test },
 335   {"var/run rm", 0, var_run_rm_test },
 336   {"var/log rm", 0, var_log_rm_test },
 337   {0, 0, 0}
 338 };
 339
 340 test_st comparison_tests[] ={
 341   {"_compare(test_return_t)", 0, _compare_test_return_t_test },
 342   {"_compare(memcached_return_t)", 0, _compare_memcached_return_t_test },
 343   {"_compare(gearman_return_t)", 0, _compare_gearman_return_t_test },
 344   {0, 0, 0}
 345 };
 346
 347 collection_st collection[] ={
 348   {"environment", 0, 0, environment_tests},
 349   {"return values", 0, 0, tests_log},
 350   {"local", 0, 0, local_log},
 351   {"directories", 0, 0, directories_tests},
 352   {"comparison", 0, 0, comparison_tests},
 353   {"gearmand", 0, 0, gearmand_tests},
 354   {"memcached", 0, 0, memcached_tests},
 355   {0, 0, 0, 0}
 356 };
 357
 358 static void *world_create(server_startup_st& servers, test_return_t&)
 359 {
 360   return &servers;
 361 }
 362
 363 void get_world(Framework *world)
 364 {
 365   world->collections= collection;
 366   world->_create= world_create;
 367 }