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 #ifdef  __cplusplus
  13 extern "C" {
  14 #endif
  15
  16 /* The structure we use for the test system */
  17 typedef struct
  18 {
  19   server_startup_st construct;
  20   memcached_st *parent;
  21   memcached_st *memc;
  22 } libmemcached_test_container_st;
  23
  24 /* Prototypes for functions we will pass to test framework */
  25 libmemcached_test_container_st *world_create(test_return_t *error);
  26 test_return_t world_test_startup(libmemcached_test_container_st *);
  27 test_return_t world_flush(libmemcached_test_container_st *container);
  28 test_return_t world_pre_run(libmemcached_test_container_st *);
  29
  30 test_return_t world_post_run(libmemcached_test_container_st *);
  31 test_return_t world_on_error(test_return_t, libmemcached_test_container_st *);
  32 test_return_t world_destroy(libmemcached_test_container_st *);
  33
  34 static libmemcached_test_container_st global_container;
  35
  36 /**
  37   @note generic shutdown/startup for libmemcached tests.
  38 */
  39 test_return_t world_container_startup(libmemcached_test_container_st *container);
  40 test_return_t world_container_shutdown(libmemcached_test_container_st *container);
  41
  42 libmemcached_test_container_st *world_create(test_return_t *error)
  43 {
  44   memset(&global_container, 0, sizeof(global_container));
  45   global_container.construct.count= SERVERS_TO_CREATE;
  46   global_container.construct.udp= 0;
  47   server_startup(&global_container.construct);
  48
  49   if (! global_container.construct.servers)
  50   {
  51     *error= TEST_FAILURE;
  52     server_shutdown(&global_container.construct);
  53     return NULL;
  54   }
  55
  56   *error= TEST_SUCCESS;
  57
  58   return &global_container;
  59 }
  60
  61 test_return_t world_container_startup(libmemcached_test_container_st *container)
  62 {
  63   memcached_return_t rc;
  64   container->parent= memcached_create(NULL);
  65   test_truth((container->parent != NULL));
  66
  67   rc= memcached_server_push(container->parent, container->construct.servers);
  68   test_truth(rc == MEMCACHED_SUCCESS);
  69
  70   return TEST_SUCCESS;
  71 }
  72
  73 test_return_t world_container_shutdown(libmemcached_test_container_st *container)
  74 {
  75   memcached_free(container->parent);
  76   container->parent= NULL;
  77
  78   return TEST_SUCCESS;
  79 }
  80
  81 test_return_t world_test_startup(libmemcached_test_container_st *container)
  82 {
  83   container->memc= memcached_clone(NULL, container->parent);
  84   test_truth((container->memc != NULL));
  85
  86   return TEST_SUCCESS;
  87 }
  88
  89 test_return_t world_flush(libmemcached_test_container_st *container)
  90 {
  91   memcached_flush(container->memc, 0);
  92   memcached_quit(container->memc);
  93
  94   return TEST_SUCCESS;
  95 }
  96
  97 test_return_t world_pre_run(libmemcached_test_container_st *container)
  98 {
  99   uint32_t loop;
 100
 101   for (loop= 0; loop < memcached_server_list_count(container->construct.servers); loop++)
 102   {
 103     memcached_server_st *instance=
 104       memcached_server_instance_fetch(container->memc, loop);
 105
 106     test_truth(instance->fd == -1);
 107     test_truth(instance->cursor_active == 0);
 108   }
 109
 110   return TEST_SUCCESS;
 111 }
 112
 113
 114 test_return_t world_post_run(libmemcached_test_container_st *container)
 115 {
 116   assert(container->memc);
 117
 118   return TEST_SUCCESS;
 119 }
 120
 121 test_return_t world_on_error(test_return_t test_state, libmemcached_test_container_st *container)
 122 {
 123   (void)test_state;
 124   memcached_free(container->memc);
 125   container->memc= NULL;
 126
 127   return TEST_SUCCESS;
 128 }
 129
 130 test_return_t world_destroy(libmemcached_test_container_st *container)
 131 {
 132   server_startup_st *construct= &container->construct;
 133   memcached_server_st *servers= container->construct.servers;
 134   memcached_server_list_free(servers);
 135
 136   server_shutdown(construct);
 137
 138   return TEST_SUCCESS;
 139 }
 140
 141 typedef test_return_t (*libmemcached_test_callback_fn)(memcached_st *);
 142 static test_return_t _runner_default(libmemcached_test_callback_fn func, libmemcached_test_container_st *container)
 143 {
 144   if (func)
 145   {
 146     return func(container->memc);
 147   }
 148   else
 149   {
 150     return TEST_SUCCESS;
 151   }
 152 }
 153
 154 #ifdef  __cplusplus
 155 }
 156 #endif
 157
 158 #ifdef  __cplusplus
 159
 160 static world_runner_st defualt_libmemcached_runner= {
 161   reinterpret_cast<test_callback_runner_fn>(_runner_default),
 162   reinterpret_cast<test_callback_runner_fn>(_runner_default),
 163   reinterpret_cast<test_callback_runner_fn>(_runner_default)
 164 };
 165
 166 #else
 167
 168 static world_runner_st defualt_libmemcached_runner= {
 169   (test_callback_runner_fn)_runner_default,
 170   (test_callback_runner_fn)_runner_default,
 171   (test_callback_runner_fn)_runner_default
 172 };
 173
 174 #endif