git.m6w6.name Git - m6w6/libmemcached/blob - tests/atomsmasher.c

   1 /*
   2   Sample test application.
   3 */
   4 #include "libmemcached/common.h"
   5
   6 #include <assert.h>
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include <sys/time.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <unistd.h>
  14 #include <time.h>
  15 #include "server.h"
  16 #include "../clients/generator.h"
  17 #include "../clients/execute.h"
  18
  19 #ifndef INT64_MAX
  20 #define INT64_MAX LONG_MAX
  21 #endif
  22 #ifndef INT32_MAX
  23 #define INT32_MAX INT_MAX
  24 #endif
  25
  26
  27 #include "test.h"
  28
  29 /* Number of items generated for tests */
  30 #define GLOBAL_COUNT 100000
  31
  32 /* Number of times to run the test loop */
  33 #define TEST_COUNTER 500000
  34 static uint32_t global_count;
  35
  36 static pairs_st *global_pairs;
  37 static char *global_keys[GLOBAL_COUNT];
  38 static size_t global_keys_length[GLOBAL_COUNT];
  39
  40 static test_return_t cleanup_pairs(memcached_st *memc __attribute__((unused)))
  41 {
  42   pairs_free(global_pairs);
  43
  44   return 0;
  45 }
  46
  47 static test_return_t generate_pairs(memcached_st *memc __attribute__((unused)))
  48 {
  49   unsigned long long x;
  50   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
  51   global_count= GLOBAL_COUNT;
  52
  53   for (x= 0; x < global_count; x++)
  54   {
  55     global_keys[x]= global_pairs[x].key;
  56     global_keys_length[x]=  global_pairs[x].key_length;
  57   }
  58
  59   return 0;
  60 }
  61
  62 static test_return_t drizzle(memcached_st *memc)
  63 {
  64   unsigned int x;
  65   memcached_return rc;
  66   char *return_value;
  67   size_t return_value_length;
  68   uint32_t flags;
  69
  70 infinite:
  71   for (x= 0; x < TEST_COUNTER; x++)
  72   {
  73     uint32_t test_bit;
  74     uint8_t which;
  75
  76     test_bit= (uint32_t)(random() % GLOBAL_COUNT);
  77     which= (uint8_t)(random() % 2);
  78
  79     if (which == 0)
  80     {
  81       return_value= memcached_get(memc, global_keys[test_bit], global_keys_length[test_bit],
  82                                   &return_value_length, &flags, &rc);
  83       if (rc == MEMCACHED_SUCCESS && return_value)
  84         free(return_value);
  85       else if (rc == MEMCACHED_NOTFOUND)
  86         continue;
  87       else
  88       {
  89         WATCHPOINT_ERROR(rc);
  90         WATCHPOINT_ASSERT(rc);
  91       }
  92     }
  93     else
  94     {
  95       rc= memcached_set(memc, global_pairs[test_bit].key,
  96                         global_pairs[test_bit].key_length,
  97                         global_pairs[test_bit].value,
  98                         global_pairs[test_bit].value_length,
  99                         0, 0);
 100       if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
 101       {
 102         WATCHPOINT_ERROR(rc);
 103         WATCHPOINT_ASSERT(0);
 104       }
 105     }
 106   }
 107
 108   if (getenv("MEMCACHED_ATOM_BURIN_IN"))
 109     goto infinite;
 110
 111   return 0;
 112 }
 113
 114 static memcached_return pre_nonblock(memcached_st *memc)
 115 {
 116   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
 117
 118   return MEMCACHED_SUCCESS;
 119 }
 120
 121 static memcached_return pre_md5(memcached_st *memc)
 122 {
 123   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
 124
 125   return MEMCACHED_SUCCESS;
 126 }
 127
 128 static memcached_return pre_hsieh(memcached_st *memc)
 129 {
 130   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
 131
 132   return MEMCACHED_SUCCESS;
 133 }
 134
 135 static memcached_return enable_consistent(memcached_st *memc)
 136 {
 137   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
 138   memcached_hash hash;
 139   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
 140   pre_hsieh(memc);
 141
 142   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
 143   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
 144
 145   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
 146   assert(hash == MEMCACHED_HASH_HSIEH);
 147
 148
 149   return MEMCACHED_SUCCESS;
 150 }
 151
 152 /*
 153   Set the value, then quit to make sure it is flushed.
 154   Come back in and test that add fails.
 155 */
 156 static test_return_t add_test(memcached_st *memc)
 157 {
 158   memcached_return rc;
 159   const char *key= "foo";
 160   const char *value= "when we sanitize";
 161   unsigned long long setting_value;
 162
 163   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 164
 165   rc= memcached_set(memc, key, strlen(key),
 166                     value, strlen(value),
 167                     (time_t)0, (uint32_t)0);
 168   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 169   memcached_quit(memc);
 170   rc= memcached_add(memc, key, strlen(key),
 171                     value, strlen(value),
 172                     (time_t)0, (uint32_t)0);
 173
 174   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 175   if (setting_value)
 176     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
 177   else
 178     assert(rc == MEMCACHED_NOTSTORED);
 179
 180   return 0;
 181 }
 182
 183 /*
 184  * repeating add_tests many times
 185  * may show a problem in timing
 186  */
 187 static test_return_t many_adds(memcached_st *memc)
 188 {
 189   unsigned int i;
 190   for (i = 0; i < TEST_COUNTER; i++)
 191   {
 192     add_test(memc);
 193   }
 194   return 0;
 195 }
 196
 197 test_st smash_tests[] ={
 198   {"generate_pairs", 1, generate_pairs },
 199   {"drizzle", 1, drizzle },
 200   {"cleanup", 1, cleanup_pairs },
 201   {"many_adds", 1, many_adds },
 202   {0, 0, 0}
 203 };
 204
 205
 206 collection_st collection[] ={
 207   {"smash", 0, 0, smash_tests},
 208   {"smash_hsieh", pre_hsieh, 0, smash_tests},
 209   {"smash_hsieh_consistent", enable_consistent, 0, smash_tests},
 210   {"smash_md5", pre_md5, 0, smash_tests},
 211   {"smash_nonblock", pre_nonblock, 0, smash_tests},
 212   {0, 0, 0, 0}
 213 };
 214
 215 #define SERVERS_TO_CREATE 5
 216
 217 static void *world_create(void)
 218 {
 219   server_startup_st *construct;
 220
 221   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
 222   memset(construct, 0, sizeof(server_startup_st));
 223   construct->count= SERVERS_TO_CREATE;
 224   construct->udp= 0;
 225   server_startup(construct);
 226
 227   return construct;
 228 }
 229
 230 static void world_destroy(void *p)
 231 {
 232   server_startup_st *construct= (server_startup_st *)p;
 233   memcached_server_st *servers= (memcached_server_st *)construct->servers;
 234   memcached_server_list_free(servers);
 235
 236   server_shutdown(construct);
 237   free(construct);
 238 }
 239
 240 void get_world(world_st *world)
 241 {
 242   world->collections= collection;
 243   world->create= world_create;
 244   world->destroy= world_destroy;
 245 }