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 #define SERVERS_TO_CREATE 5
  31 #define TEST_PORT_BASE MEMCACHED_DEFAULT_PORT +10
  32
  33 static void *world_create(server_startup_st& servers, test_return_t& error)
  34 {
  35   in_port_t max_port;
  36   for (uint32_t x= 0; x < SERVERS_TO_CREATE; x++)
  37   {
  38     in_port_t port;
  39
  40     char variable_buffer[1024];
  41     snprintf(variable_buffer, sizeof(variable_buffer), "LIBMEMCACHED_PORT_%u", x);
  42
  43     char *var;
  44     if ((var= getenv(variable_buffer)))
  45     {
  46       port= in_port_t(atoi(var));
  47     }
  48     else
  49     {
  50       port= in_port_t(TEST_PORT_BASE +x);
  51     }
  52
  53     max_port= port;
  54     const char *argv[1]= { "memcached" };
  55     if (not server_startup(servers, "memcached", port, 1, argv))
  56     {
  57       error= TEST_FAILURE;
  58       return NULL;
  59     }
  60   }
  61
  62   const char *argv[1]= { "memcached" };
  63   if (not servers.start_socket_server("memcached", max_port +1, 1, argv))
  64   {
  65     error= TEST_FAILURE;
  66     return NULL;
  67   }
  68
  69
  70   libmemcached_test_container_st *global_container= new libmemcached_test_container_st(servers);
  71   if (global_container == NULL)
  72   {
  73     error= TEST_MEMORY_ALLOCATION_FAILURE;
  74     return NULL;
  75   }
  76
  77   error= TEST_SUCCESS;
  78
  79   return global_container;
  80 }
  81
  82 static test_return_t world_container_startup(libmemcached_test_container_st *container)
  83 {
  84   char buffer[BUFSIZ];
  85
  86   test_compare_got(MEMCACHED_SUCCESS,
  87                    libmemcached_check_configuration(container->construct.option_string().c_str(), container->construct.option_string().size(),
  88                                                     buffer, sizeof(buffer)),
  89                    container->construct.option_string().c_str());
  90
  91   test_true(not container->parent);
  92   container->parent= memcached(container->construct.option_string().c_str(), container->construct.option_string().size());
  93   test_true(container->parent);
  94
  95   for (uint32_t host= 0; host < memcached_server_count(container->parent); ++host)
  96   {
  97     memcached_server_instance_st instance=
  98       memcached_server_instance_by_position(container->parent, host);
  99
 100     if (instance->type == MEMCACHED_CONNECTION_TCP)
 101     {
 102       test_true_got(memcached_server_port(instance) >= TEST_PORT_BASE, memcached_server_port(instance));
 103     }
 104   }
 105
 106   return TEST_SUCCESS;
 107 }
 108
 109 static test_return_t world_container_shutdown(libmemcached_test_container_st *container)
 110 {
 111   memcached_free(container->parent);
 112   container->parent= NULL;
 113
 114   return TEST_SUCCESS;
 115 }
 116
 117 static test_return_t world_test_startup(libmemcached_test_container_st *container)
 118 {
 119   test_true(container);
 120   test_true(not container->memc);
 121   test_true(container->parent);
 122   container->memc= memcached_clone(NULL, container->parent);
 123   test_true(container->memc);
 124
 125   return TEST_SUCCESS;
 126 }
 127
 128 test_return_t world_flush(libmemcached_test_container_st *container);
 129 test_return_t world_flush(libmemcached_test_container_st *container)
 130 {
 131   test_true(container->memc);
 132   memcached_flush(container->memc, 0);
 133   memcached_quit(container->memc);
 134
 135   return TEST_SUCCESS;
 136 }
 137
 138 static test_return_t world_pre_run(libmemcached_test_container_st *container)
 139 {
 140   test_true(container->memc);
 141   for (uint32_t loop= 0; loop < memcached_server_list_count(container->memc->servers); loop++)
 142   {
 143     memcached_server_instance_st instance=
 144       memcached_server_instance_by_position(container->memc, loop);
 145
 146     test_compare(-1, instance->fd);
 147     test_compare(0U, instance->cursor_active);
 148   }
 149
 150   return TEST_SUCCESS;
 151 }
 152
 153
 154 static test_return_t world_post_run(libmemcached_test_container_st *container)
 155 {
 156   test_true(container->memc);
 157
 158   return TEST_SUCCESS;
 159 }
 160
 161 static test_return_t world_on_error(test_return_t test_state, libmemcached_test_container_st *container)
 162 {
 163   (void)test_state;
 164   test_true(container->memc);
 165   memcached_free(container->memc);
 166   container->memc= NULL;
 167
 168   return TEST_SUCCESS;
 169 }
 170
 171 static bool world_destroy(void *object)
 172 {
 173   libmemcached_test_container_st *container= (libmemcached_test_container_st *)object;
 174 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
 175   sasl_done();
 176 #endif
 177
 178   delete container;
 179
 180   return TEST_SUCCESS;
 181 }
 182
 183 typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *);
 184
 185 static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 186 {
 187   if (func)
 188   {
 189     test_true(container);
 190     test_true(container->memc);
 191     return func(container->memc);
 192   }
 193
 194   return TEST_SUCCESS;
 195 }
 196
 197 static test_return_t _pre_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 198 {
 199   if (func)
 200   {
 201     return func(container->parent);
 202   }
 203
 204   return TEST_SUCCESS;
 205 }
 206
 207 static test_return_t _post_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 208 {
 209   if (func)
 210   {
 211     return func(container->parent);
 212   }
 213
 214   return TEST_SUCCESS;
 215 }
 216
 217 class LibmemcachedRunner : public Runner {
 218 public:
 219   test_return_t run(test_callback_fn* func, void *object)
 220   {
 221     return _runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 222   }
 223
 224   test_return_t pre(test_callback_fn* func, void *object)
 225   {
 226     return _pre_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 227   }
 228
 229   test_return_t post(test_callback_fn* func, void *object)
 230   {
 231     return _post_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 232   }
 233 };
 234
 235 static LibmemcachedRunner defualt_libmemcached_runner;