git.m6w6.name Git - m6w6/libmemcached/blob - tests/libmemcached_world.h

   1 /* libMemcached Functions Test
   2  * Copyright (C) 2006-2009 Brian Aker
   3  * All rights reserved.
   4  *
   5  * Use and distribution licensed under the BSD license.  See
   6  * the COPYING file in the parent directory for full text.
   7  *
   8  * Description: This is the startup bits for any libmemcached test.
   9  *
  10  */
  11
  12 #pragma once
  13
  14 #include <cassert>
  15
  16 /* The structure we use for the test system */
  17 struct libmemcached_test_container_st
  18 {
  19   server_startup_st& construct;
  20   memcached_st *parent;
  21   memcached_st *memc;
  22
  23   libmemcached_test_container_st(server_startup_st &construct_arg) :
  24     construct(construct_arg),
  25     parent(NULL),
  26     memc(NULL)
  27   { }
  28 };
  29
  30 static void *world_create(server_startup_st& servers, test_return_t& error)
  31 {
  32   if (HAVE_MEMCACHED_BINARY == 0)
  33   {
  34     error= TEST_FATAL;
  35     return NULL;
  36   }
  37
  38   if (servers.sasl() and (LIBMEMCACHED_WITH_SASL_SUPPORT == 0 or MEMCACHED_SASL_BINARY == 0))
  39   {
  40     error= TEST_SKIPPED;
  41     return NULL;
  42   }
  43
  44   // Assume we are running under valgrind, and bail
  45   if (servers.sasl() and getenv("TESTS_ENVIRONMENT"))
  46   {
  47     error= TEST_SKIPPED;
  48     return NULL;
  49   }
  50
  51
  52   in_port_t max_port= TEST_PORT_BASE;
  53   for (uint32_t x= 0; x < servers.count(); x++)
  54   {
  55     in_port_t port;
  56
  57     char variable_buffer[1024];
  58     snprintf(variable_buffer, sizeof(variable_buffer), "LIBMEMCACHED_PORT_%u", x);
  59
  60     char *var;
  61     if ((var= getenv(variable_buffer)))
  62     {
  63       port= in_port_t(atoi(var));
  64     }
  65     else
  66     {
  67       port= in_port_t(TEST_PORT_BASE +x);
  68     }
  69
  70     max_port= port;
  71     const char *argv[1]= { "memcached" };
  72     if (servers.sasl())
  73     {
  74       if (not server_startup(servers, "memcached-sasl", port, 1, argv))
  75       {
  76         error= TEST_FATAL;
  77         return NULL;
  78       }
  79     }
  80     else
  81     {
  82       if (not server_startup(servers, "memcached", port, 1, argv))
  83       {
  84         error= TEST_FATAL;
  85         return NULL;
  86       }
  87     }
  88   }
  89
  90   if (servers.socket())
  91   {
  92     if (servers.sasl())
  93     {
  94       const char *argv[1]= { "memcached" };
  95       if (not servers.start_socket_server("memcached-sasl", max_port +1, 1, argv))
  96       {
  97         error= TEST_FATAL;
  98         return NULL;
  99       }
 100     }
 101     else
 102     {
 103       const char *argv[1]= { "memcached" };
 104       if (not servers.start_socket_server("memcached", max_port +1, 1, argv))
 105       {
 106         error= TEST_FATAL;
 107         return NULL;
 108       }
 109     }
 110   }
 111
 112
 113   libmemcached_test_container_st *global_container= new libmemcached_test_container_st(servers);
 114   if (global_container == NULL)
 115   {
 116     error= TEST_MEMORY_ALLOCATION_FAILURE;
 117     return NULL;
 118   }
 119
 120   error= TEST_SUCCESS;
 121
 122   return global_container;
 123 }
 124
 125 static test_return_t world_container_startup(libmemcached_test_container_st *container)
 126 {
 127   char buffer[BUFSIZ];
 128
 129   test_compare_got(MEMCACHED_SUCCESS,
 130                    libmemcached_check_configuration(container->construct.option_string().c_str(), container->construct.option_string().size(),
 131                                                     buffer, sizeof(buffer)),
 132                    container->construct.option_string().c_str());
 133
 134   test_true(not container->parent);
 135   container->parent= memcached(container->construct.option_string().c_str(), container->construct.option_string().size());
 136   test_true(container->parent);
 137
 138   if (container->construct.sasl())
 139   {
 140     if (memcached_failed(memcached_behavior_set(container->parent, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)))
 141     {
 142       memcached_free(container->parent);
 143       return TEST_FAILURE;
 144     }
 145
 146     if (memcached_failed(memcached_set_sasl_auth_data(container->parent, container->construct.username().c_str(), container->construct.password().c_str())))
 147     {
 148       memcached_free(container->parent);
 149       return TEST_FAILURE;
 150     }
 151   }
 152
 153   for (uint32_t host= 0; host < memcached_server_count(container->parent); ++host)
 154   {
 155     memcached_server_instance_st instance=
 156       memcached_server_instance_by_position(container->parent, host);
 157
 158     if (instance->type == MEMCACHED_CONNECTION_TCP)
 159     {
 160       test_true_got(memcached_server_port(instance) >= TEST_PORT_BASE, memcached_server_port(instance));
 161     }
 162   }
 163
 164   return TEST_SUCCESS;
 165 }
 166
 167 static test_return_t world_container_shutdown(libmemcached_test_container_st *container)
 168 {
 169   memcached_free(container->parent);
 170   container->parent= NULL;
 171
 172   return TEST_SUCCESS;
 173 }
 174
 175 static test_return_t world_test_startup(libmemcached_test_container_st *container)
 176 {
 177   test_true(container);
 178   test_true(not container->memc);
 179   test_true(container->parent);
 180   container->memc= memcached_clone(NULL, container->parent);
 181   test_true(container->memc);
 182
 183   return TEST_SUCCESS;
 184 }
 185
 186 test_return_t world_flush(libmemcached_test_container_st *container);
 187 test_return_t world_flush(libmemcached_test_container_st *container)
 188 {
 189   test_true(container->memc);
 190   memcached_flush(container->memc, 0);
 191   memcached_quit(container->memc);
 192
 193   return TEST_SUCCESS;
 194 }
 195
 196 static test_return_t world_pre_run(libmemcached_test_container_st *container)
 197 {
 198   test_true(container->memc);
 199   for (uint32_t loop= 0; loop < memcached_server_list_count(container->memc->servers); loop++)
 200   {
 201     memcached_server_instance_st instance=
 202       memcached_server_instance_by_position(container->memc, loop);
 203
 204     test_compare(-1, instance->fd);
 205     test_compare(0U, instance->cursor_active);
 206   }
 207
 208   return TEST_SUCCESS;
 209 }
 210
 211
 212 static test_return_t world_post_run(libmemcached_test_container_st *container)
 213 {
 214   test_true(container->memc);
 215
 216   return TEST_SUCCESS;
 217 }
 218
 219 static test_return_t world_on_error(test_return_t test_state, libmemcached_test_container_st *container)
 220 {
 221   (void)test_state;
 222   test_true(container->memc);
 223   memcached_free(container->memc);
 224   container->memc= NULL;
 225
 226   return TEST_SUCCESS;
 227 }
 228
 229 static bool world_destroy(void *object)
 230 {
 231   libmemcached_test_container_st *container= (libmemcached_test_container_st *)object;
 232 #if defined(LIBMEMCACHED_WITH_SASL_SUPPORT) && LIBMEMCACHED_WITH_SASL_SUPPORT
 233   if (LIBMEMCACHED_WITH_SASL_SUPPORT)
 234   {
 235     sasl_done();
 236   }
 237 #endif
 238
 239   delete container;
 240
 241   return TEST_SUCCESS;
 242 }
 243
 244 typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *);
 245
 246 static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 247 {
 248   if (func)
 249   {
 250     test_true(container);
 251     test_true(container->memc);
 252     return func(container->memc);
 253   }
 254
 255   return TEST_SUCCESS;
 256 }
 257
 258 static test_return_t _pre_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 259 {
 260   if (func)
 261   {
 262     return func(container->parent);
 263   }
 264
 265   return TEST_SUCCESS;
 266 }
 267
 268 static test_return_t _post_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 269 {
 270   if (func)
 271   {
 272     return func(container->parent);
 273   }
 274
 275   return TEST_SUCCESS;
 276 }
 277
 278 class LibmemcachedRunner : public Runner {
 279 public:
 280   test_return_t run(test_callback_fn* func, void *object)
 281   {
 282     return _runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 283   }
 284
 285   test_return_t pre(test_callback_fn* func, void *object)
 286   {
 287     return _pre_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 288   }
 289
 290   test_return_t post(test_callback_fn* func, void *object)
 291   {
 292     return _post_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 293   }
 294 };
 295
 296 static LibmemcachedRunner defualt_libmemcached_runner;