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   char buffer[1024];
 144   const char *dir= getcwd(buffer, sizeof(buffer));
 145   test_true_got(file, dir);
 146   fclose(file);
 147   return TEST_SUCCESS;
 148 }
 149
 150 static test_return_t var_run_test(void *)
 151 {
 152   FILE *file= fopen("var/run/junk", "w+");
 153   test_true(file);
 154   fclose(file);
 155   return TEST_SUCCESS;
 156 }
 157
 158 static test_return_t var_log_test(void *)
 159 {
 160   FILE *file= fopen("var/log/junk", "w+");
 161   test_true(file);
 162   fclose(file);
 163   return TEST_SUCCESS;
 164 }
 165
 166 static test_return_t var_tmp_rm_test(void *)
 167 {
 168   test_true(unlink("var/tmp/junk") == 0);
 169   return TEST_SUCCESS;
 170 }
 171
 172 static test_return_t var_run_rm_test(void *)
 173 {
 174   test_true(unlink("var/run/junk") == 0);
 175   return TEST_SUCCESS;
 176 }
 177
 178 static test_return_t var_log_rm_test(void *)
 179 {
 180   test_true(unlink("var/log/junk") == 0);
 181   return TEST_SUCCESS;
 182 }
 183
 184 static test_return_t gearmand_cycle_test(void *object)
 185 {
 186   server_startup_st *servers= (server_startup_st*)object;
 187   test_true(servers);
 188
 189   if (HAVE_LIBGEARMAN)
 190   {
 191     const char *argv[1]= { "cycle_gearmand" };
 192     test_true(server_startup(*servers, "gearmand", 9999, 1, argv));
 193
 194     return TEST_SUCCESS;
 195   }
 196
 197   return TEST_SKIPPED;
 198 }
 199
 200 static test_return_t memcached_cycle_test(void *object)
 201 {
 202   server_startup_st *servers= (server_startup_st*)object;
 203   test_true(servers);
 204
 205   if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
 206   {
 207     const char *argv[1]= { "cycle_memcached" };
 208     test_true(server_startup(*servers, "memcached", 9998, 1, argv));
 209
 210     return TEST_SUCCESS;
 211   }
 212
 213   return TEST_SKIPPED;
 214 }
 215
 216 static test_return_t memcached_socket_cycle_test(void *object)
 217 {
 218   server_startup_st *servers= (server_startup_st*)object;
 219   test_true(servers);
 220
 221   if (MEMCACHED_BINARY and HAVE_LIBMEMCACHED)
 222   {
 223     const char *argv[1]= { "cycle_memcached" };
 224     test_true(servers->start_socket_server("memcached", 9997, 1, argv));
 225
 226     return TEST_SUCCESS;
 227   }
 228
 229   return TEST_SKIPPED;
 230 }
 231
 232 test_st gearmand_tests[] ={
 233 #if 0
 234   {"pause", 0, pause_test },
 235 #endif
 236   {"gearmand startup-shutdown", 0, gearmand_cycle_test },
 237   {0, 0, 0}
 238 };
 239
 240 test_st memcached_tests[] ={
 241   {"memcached startup-shutdown", 0, memcached_cycle_test },
 242   {"memcached(socket file) startup-shutdown", 0, memcached_socket_cycle_test },
 243   {0, 0, 0}
 244 };
 245
 246 test_st environment_tests[] ={
 247   {"LIBTOOL_COMMAND", 0, LIBTOOL_COMMAND_test },
 248   {"VALGRIND_COMMAND", 0, VALGRIND_COMMAND_test },
 249   {"HELGRIND_COMMAND", 0, HELGRIND_COMMAND_test },
 250   {"GDB_COMMAND", 0, GDB_COMMAND_test },
 251   {0, 0, 0}
 252 };
 253
 254 test_st tests_log[] ={
 255   {"TEST_SUCCESS", 0, test_success_test },
 256   {"TEST_FAILURE", 0, test_failure_test },
 257   {0, 0, 0}
 258 };
 259
 260 test_st local_log[] ={
 261   {"test_is_local()", 0, local_test },
 262   {"test_is_local(NOT)", 0, local_not_test },
 263   {0, 0, 0}
 264 };
 265
 266 test_st directories_tests[] ={
 267   {"var exists", 0, var_exists_test },
 268   {"var/tmp exists", 0, var_tmp_exists_test },
 269   {"var/run exists", 0, var_run_exists_test },
 270   {"var/log exists", 0, var_log_exists_test },
 271   {"var/tmp", 0, var_tmp_test },
 272   {"var/run", 0, var_run_test },
 273   {"var/log", 0, var_log_test },
 274   {"var/tmp rm", 0, var_tmp_rm_test },
 275   {"var/run rm", 0, var_run_rm_test },
 276   {"var/log rm", 0, var_log_rm_test },
 277   {0, 0, 0}
 278 };
 279
 280 collection_st collection[] ={
 281   {"environment", 0, 0, environment_tests},
 282   {"return values", 0, 0, tests_log},
 283   {"local", 0, 0, local_log},
 284   {"directories", 0, 0, directories_tests},
 285   {"gearmand", 0, 0, gearmand_tests},
 286   {"memcached", 0, 0, memcached_tests},
 287   {0, 0, 0, 0}
 288 };
 289
 290 static void *world_create(server_startup_st& servers, test_return_t&)
 291 {
 292   return &servers;
 293 }
 294
 295 void get_world(Framework *world)
 296 {
 297   world->collections= collection;
 298   world->_create= world_create;
 299 }