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

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Libmemcached Client and Server
   4  *
   5  *  Copyright (C) 2011-2012 Data Differential, http://datadifferential.com/
   6  *  Copyright (C) 2006-2009 Brian Aker
   7  *  All rights reserved.
   8  *
   9  *  Redistribution and use in source and binary forms, with or without
  10  *  modification, are permitted provided that the following conditions are
  11  *  met:
  12  *
  13  *      * Redistributions of source code must retain the above copyright
  14  *  notice, this list of conditions and the following disclaimer.
  15  *
  16  *      * Redistributions in binary form must reproduce the above
  17  *  copyright notice, this list of conditions and the following disclaimer
  18  *  in the documentation and/or other materials provided with the
  19  *  distribution.
  20  *
  21  *      * The names of its contributors may not be used to endorse or
  22  *  promote products derived from this software without specific prior
  23  *  written permission.
  24  *
  25  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  */
  38
  39
  40 #pragma once
  41
  42 #include <cassert>
  43
  44 /* The structure we use for the test system */
  45 struct libmemcached_test_container_st
  46 {
  47   libtest::server_startup_st& construct;
  48   memcached_st *parent;
  49   memcached_st *memc;
  50
  51   libmemcached_test_container_st(libtest::server_startup_st &construct_arg) :
  52     construct(construct_arg),
  53     parent(NULL),
  54     memc(NULL)
  55   { }
  56 };
  57
  58 static void *world_create(libtest::server_startup_st& servers, test_return_t& error)
  59 {
  60   if (HAVE_MEMCACHED_BINARY == 0)
  61   {
  62     error= TEST_SKIPPED;
  63     return NULL;
  64   }
  65
  66   for (uint32_t x= 0; x < servers.count(); x++)
  67   {
  68     const char *argv[1]= { "memcached" };
  69     if (not servers.start_socket_server("memcached", libtest::get_free_port(), 1, argv))
  70     {
  71       error= TEST_FATAL;
  72       return NULL;
  73     }
  74   }
  75
  76
  77   libmemcached_test_container_st *global_container= new libmemcached_test_container_st(servers);
  78   if (global_container == NULL)
  79   {
  80     error= TEST_MEMORY_ALLOCATION_FAILURE;
  81     return NULL;
  82   }
  83
  84   error= TEST_SUCCESS;
  85
  86   return global_container;
  87 }
  88
  89 static test_return_t world_container_startup(libmemcached_test_container_st *container)
  90 {
  91   char buffer[BUFSIZ];
  92
  93   test_compare_got(MEMCACHED_SUCCESS,
  94                    libmemcached_check_configuration(container->construct.option_string().c_str(), container->construct.option_string().size(),
  95                                                     buffer, sizeof(buffer)),
  96                    container->construct.option_string().c_str());
  97
  98   test_null(container->parent);
  99   container->parent= memcached(container->construct.option_string().c_str(), container->construct.option_string().size());
 100   test_true(container->parent);
 101   test_compare(MEMCACHED_SUCCESS, memcached_version(container->parent));
 102
 103   if (container->construct.sasl())
 104   {
 105     if (memcached_failed(memcached_behavior_set(container->parent, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1)))
 106     {
 107       memcached_free(container->parent);
 108       return TEST_FAILURE;
 109     }
 110
 111     if (memcached_failed(memcached_set_sasl_auth_data(container->parent, container->construct.username().c_str(), container->construct.password().c_str())))
 112     {
 113       memcached_free(container->parent);
 114       return TEST_FAILURE;
 115     }
 116   }
 117
 118   return TEST_SUCCESS;
 119 }
 120
 121 static test_return_t world_container_shutdown(libmemcached_test_container_st *container)
 122 {
 123   memcached_free(container->parent);
 124   container->parent= NULL;
 125
 126   return TEST_SUCCESS;
 127 }
 128
 129 static test_return_t world_test_startup(libmemcached_test_container_st *container)
 130 {
 131   test_true(container);
 132   test_null(container->memc);
 133   test_true(container->parent);
 134   container->memc= memcached_clone(NULL, container->parent);
 135   test_true(container->memc);
 136
 137   return TEST_SUCCESS;
 138 }
 139
 140 test_return_t world_flush(libmemcached_test_container_st *container);
 141 test_return_t world_flush(libmemcached_test_container_st *container)
 142 {
 143   test_true(container->memc);
 144   memcached_flush(container->memc, 0);
 145   memcached_quit(container->memc);
 146
 147   return TEST_SUCCESS;
 148 }
 149
 150 static test_return_t world_pre_run(libmemcached_test_container_st *container)
 151 {
 152   test_true(container->memc);
 153   for (uint32_t loop= 0; loop < memcached_server_list_count(container->memc->servers); loop++)
 154   {
 155     memcached_server_instance_st instance=
 156       memcached_server_instance_by_position(container->memc, loop);
 157
 158     test_compare(-1, instance->fd);
 159     test_compare(0U, instance->cursor_active);
 160   }
 161
 162   return TEST_SUCCESS;
 163 }
 164
 165
 166 static test_return_t world_post_run(libmemcached_test_container_st *container)
 167 {
 168   test_true(container->memc);
 169
 170   return TEST_SUCCESS;
 171 }
 172
 173 static test_return_t world_on_error(test_return_t , libmemcached_test_container_st *container)
 174 {
 175   test_true(container->memc);
 176   memcached_free(container->memc);
 177   container->memc= NULL;
 178
 179   return TEST_SUCCESS;
 180 }
 181
 182 static bool world_destroy(void *object)
 183 {
 184   libmemcached_test_container_st *container= (libmemcached_test_container_st *)object;
 185 #if defined(LIBMEMCACHED_WITH_SASL_SUPPORT) && LIBMEMCACHED_WITH_SASL_SUPPORT
 186   if (LIBMEMCACHED_WITH_SASL_SUPPORT)
 187   {
 188     sasl_done();
 189   }
 190 #endif
 191
 192   delete container;
 193
 194   return TEST_SUCCESS;
 195 }
 196
 197 typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *);
 198
 199 static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 200 {
 201   if (func)
 202   {
 203     test_true(container);
 204     test_true(container->memc);
 205     test_return_t ret;
 206     try {
 207       ret= func(container->memc);
 208     }
 209     catch (std::exception& e)
 210     {
 211       libtest::Error << e.what();
 212       return TEST_FAILURE;
 213     }
 214
 215     return ret;
 216   }
 217
 218   return TEST_SUCCESS;
 219 }
 220
 221 static test_return_t _pre_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 222 {
 223   if (func)
 224   {
 225     return func(container->parent);
 226   }
 227
 228   return TEST_SUCCESS;
 229 }
 230
 231 static test_return_t _post_runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 232 {
 233   if (func)
 234   {
 235     return func(container->parent);
 236   }
 237
 238   return TEST_SUCCESS;
 239 }
 240
 241 class LibmemcachedRunner : public libtest::Runner {
 242 public:
 243   test_return_t run(test_callback_fn* func, void *object)
 244   {
 245     return _runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 246   }
 247
 248   test_return_t pre(test_callback_fn* func, void *object)
 249   {
 250     return _pre_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 251   }
 252
 253   test_return_t post(test_callback_fn* func, void *object)
 254   {
 255     return _post_runner_default(libmemcached_test_callback_fn(func), (libmemcached_test_container_st*)object);
 256   }
 257 };
 258
 259 static LibmemcachedRunner defualt_libmemcached_runner;