git.m6w6.name Git - awesomized/libmemcached/blob - tests/test.c

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <memcached.h>
   6 #include <stdio.h>
   7 #include <stdlib.h>
   8 #include <string.h>
   9
  10 void init_test(void)
  11 {
  12   memcached_st memc;
  13
  14   (void)memcached_init(&memc);
  15   memcached_deinit(&memc);
  16 }
  17
  18 void allocation_test(void)
  19 {
  20   memcached_st *memc;
  21   memc= memcached_init(NULL);
  22   assert(memc);
  23   memcached_deinit(memc);
  24 }
  25
  26 void connection_test(void)
  27 {
  28   memcached_return rc;
  29   memcached_st *memc;
  30   memc= memcached_init(NULL);
  31   rc= memcached_server_add(memc, "localhost", 0);
  32   assert(rc == MEMCACHED_SUCCESS);
  33   assert(memc);
  34   memcached_deinit(memc);
  35 }
  36
  37 void set_test(void)
  38 {
  39   memcached_st *memc;
  40   memcached_return rc;
  41   char *key= "foo";
  42   char *value= "when we sanitize";
  43
  44   memc= memcached_init(NULL);
  45   assert(memc);
  46   rc= memcached_set(memc, key, strlen(key),
  47                     value, strlen(value),
  48                     (time_t)0, (uint16_t)0);
  49   assert(rc == MEMCACHED_SUCCESS);
  50
  51   memcached_deinit(memc);
  52 }
  53
  54 void add_test(void)
  55 {
  56   memcached_st *memc;
  57   memcached_return rc;
  58   char *key= "foo";
  59   char *value= "when we sanitize";
  60
  61   memc= memcached_init(NULL);
  62   assert(memc);
  63   rc= memcached_add(memc, key, strlen(key),
  64                     value, strlen(value),
  65                     (time_t)0, (uint16_t)0);
  66   assert(rc == MEMCACHED_NOTSTORED);
  67
  68   memcached_deinit(memc);
  69 }
  70
  71 void replace_test(void)
  72 {
  73   memcached_st *memc;
  74   memcached_return rc;
  75   char *key= "foo";
  76   char *value= "when we sanitize";
  77
  78   memc= memcached_init(NULL);
  79   assert(memc);
  80   rc= memcached_replace(memc, key, strlen(key),
  81                     value, strlen(value),
  82                     (time_t)0, (uint16_t)0);
  83   assert(rc == MEMCACHED_SUCCESS);
  84
  85   memcached_deinit(memc);
  86 }
  87
  88 void delete_test(void)
  89 {
  90   memcached_st *memc;
  91   memcached_return rc;
  92   char *key= "foo";
  93   char *value= "when we sanitize";
  94
  95   memc= memcached_init(NULL);
  96   assert(memc);
  97   rc= memcached_set(memc, key, strlen(key),
  98                     value, strlen(value),
  99                     (time_t)0, (uint16_t)0);
 100   assert(rc == MEMCACHED_SUCCESS);
 101
 102   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 103   assert(rc == MEMCACHED_SUCCESS);
 104
 105   memcached_deinit(memc);
 106 }
 107
 108 void flush_test(void)
 109 {
 110   memcached_st *memc;
 111   memcached_return rc;
 112
 113   memc= memcached_init(NULL);
 114   assert(memc);
 115   rc= memcached_flush(memc, 0);
 116   assert(rc == MEMCACHED_SUCCESS);
 117
 118   memcached_deinit(memc);
 119 }
 120
 121 void get_test(void)
 122 {
 123   memcached_st *memc;
 124   memcached_return rc;
 125   char *key= "foo";
 126   char *string;
 127   size_t string_length;
 128   uint16_t flags;
 129
 130   memc= memcached_init(NULL);
 131   assert(memc);
 132
 133   string= memcached_get(memc, key, strlen(key),
 134                         &string_length, &flags, &rc);
 135
 136   assert(rc == MEMCACHED_NOTFOUND);
 137   assert(string_length ==  0);
 138   assert(!string);
 139
 140   memcached_deinit(memc);
 141 }
 142
 143 void get_test2(void)
 144 {
 145   memcached_st *memc;
 146   memcached_return rc;
 147   char *key= "foo";
 148   char *value= "when we sanitize";
 149   char *string;
 150   size_t string_length;
 151   uint16_t flags;
 152
 153   memc= memcached_init(NULL);
 154   assert(memc);
 155   rc= memcached_set(memc, key, strlen(key),
 156                     value, strlen(value),
 157                     (time_t)0, (uint16_t)0);
 158   assert(rc == MEMCACHED_SUCCESS);
 159
 160   string= memcached_get(memc, key, strlen(key),
 161                         &string_length, &flags, &rc);
 162
 163   assert(string);
 164   assert(rc == MEMCACHED_SUCCESS);
 165   assert(string_length == strlen(value));
 166   assert(!memcmp(string, value, string_length));
 167
 168   free(string);
 169
 170   memcached_deinit(memc);
 171 }
 172
 173 void get_test3(void)
 174 {
 175   memcached_st *memc;
 176   memcached_return rc;
 177   char *key= "foo";
 178   char *value;
 179   size_t value_length= 8191;
 180   char *string;
 181   size_t string_length;
 182   uint16_t flags;
 183   int i;
 184
 185   value = (char*) malloc(value_length);
 186   for (i=0; i<value_length; i++)
 187     value[i] = (char) (i % 127);
 188
 189   memc= memcached_init(NULL);
 190   assert(memc);
 191   rc= memcached_set(memc, key, strlen(key),
 192                     value, value_length,
 193                     (time_t)0, (uint16_t)0);
 194   assert(rc == MEMCACHED_SUCCESS);
 195
 196   string= memcached_get(memc, key, strlen(key),
 197                         &string_length, &flags, &rc);
 198
 199   assert(string_length == value_length);
 200   assert(!memcmp(string, value, string_length));
 201
 202   free(string);
 203   free(value);
 204
 205   memcached_deinit(memc);
 206 }
 207
 208 void stats_hostname_test(void)
 209 {
 210   memcached_return rc;
 211   memcached_stat_st stat;
 212   rc= memcached_stat_hostname(&stat, NULL,
 213                               "localhost",
 214                               MEMCACHED_DEFAULT_PORT);
 215 }
 216
 217 void increment_test(void)
 218 {
 219   memcached_st *memc;
 220   unsigned int new_number;
 221   memcached_return rc;
 222   char *key= "number";
 223   char *value= "0";
 224
 225   memc= memcached_init(NULL);
 226   assert(memc);
 227   rc= memcached_set(memc, key, strlen(key),
 228                     value, strlen(value),
 229                     (time_t)0, (uint16_t)0);
 230   assert(rc == MEMCACHED_SUCCESS);
 231
 232   rc= memcached_increment(memc, key, strlen(key),
 233                           1, &new_number);
 234   assert(rc == MEMCACHED_SUCCESS);
 235   assert(new_number == 1);
 236
 237   rc= memcached_increment(memc, key, strlen(key),
 238                           1, &new_number);
 239   assert(rc == MEMCACHED_SUCCESS);
 240   assert(new_number == 2);
 241
 242   memcached_deinit(memc);
 243 }
 244
 245 void decrement_test(void)
 246 {
 247   memcached_st *memc;
 248   unsigned int new_number;
 249   memcached_return rc;
 250   char *key= "number";
 251   char *value= "3";
 252
 253   memc= memcached_init(NULL);
 254   assert(memc);
 255   rc= memcached_set(memc, key, strlen(key),
 256                     value, strlen(value),
 257                     (time_t)0, (uint16_t)0);
 258   assert(rc == MEMCACHED_SUCCESS);
 259
 260   rc= memcached_decrement(memc, key, strlen(key),
 261                           1, &new_number);
 262   assert(rc == MEMCACHED_SUCCESS);
 263   assert(new_number == 2);
 264
 265   rc= memcached_decrement(memc, key, strlen(key),
 266                           1, &new_number);
 267   assert(rc == MEMCACHED_SUCCESS);
 268   assert(new_number == 1);
 269
 270   memcached_deinit(memc);
 271 }
 272
 273 void quit_test(void)
 274 {
 275   memcached_st *memc;
 276   memcached_return rc;
 277   char *key= "fudge";
 278   char *value= "sanford and sun";
 279
 280   memc= memcached_init(NULL);
 281   assert(memc);
 282   rc= memcached_set(memc, key, strlen(key),
 283                     value, strlen(value),
 284                     (time_t)10, (uint16_t)3);
 285   assert(rc == MEMCACHED_SUCCESS);
 286   memcached_quit(memc);
 287
 288   rc= memcached_set(memc, key, strlen(key),
 289                     value, strlen(value),
 290                     (time_t)50, (uint16_t)9);
 291   assert(rc == MEMCACHED_SUCCESS);
 292
 293   memcached_deinit(memc);
 294 }
 295
 296 void mget_test(void)
 297 {
 298   memcached_st *memc;
 299   memcached_return rc;
 300   char *keys[]= {"fudge", "son", "food"};
 301   size_t key_length[]= {5, 3, 4};
 302   unsigned int x;
 303   uint16_t flags;
 304
 305   char return_key[MEMCACHED_MAX_KEY];
 306   size_t return_key_length;
 307   char *return_value;
 308   size_t return_value_length;
 309
 310   memc= memcached_init(NULL);
 311   assert(memc);
 312
 313   rc= memcached_mget(memc, keys, key_length, 3);
 314   assert(rc == MEMCACHED_SUCCESS);
 315
 316   while (return_value= memcached_fetch(memc, return_key, &return_key_length,
 317                       &return_value_length, &flags, &rc))
 318   {
 319     assert(return_value);
 320   }
 321   assert(return_value_length == 0);
 322   assert(rc == MEMCACHED_NOTFOUND);
 323
 324   for (x= 0; x < 3; x++)
 325   {
 326     rc= memcached_set(memc, keys[x], key_length[x],
 327                       keys[x], key_length[x],
 328                       (time_t)50, (uint16_t)9);
 329     assert(rc == MEMCACHED_SUCCESS);
 330   }
 331
 332   rc= memcached_mget(memc, keys, key_length, 3);
 333   assert(rc == MEMCACHED_SUCCESS);
 334
 335   x= 0;
 336   while (return_value= memcached_fetch(memc, return_key, &return_key_length,
 337                       &return_value_length, &flags, &rc))
 338   {
 339     assert(return_value);
 340     assert(rc == MEMCACHED_SUCCESS);
 341     assert(key_length[x] == return_value_length);
 342     assert(!memcmp(return_value, keys[x], return_value_length));
 343     free(return_value);
 344     x++;
 345   }
 346
 347   memcached_deinit(memc);
 348 }
 349
 350 void get_stats_keys(void)
 351 {
 352  char **list;
 353  char **ptr;
 354  memcached_stat_st stat;
 355  memcached_return rc;
 356
 357  list= memcached_stat_get_keys(&stat, &rc);
 358  assert(rc == MEMCACHED_SUCCESS);
 359  for (ptr= list; *ptr; ptr++)
 360    printf("Found key %s\n", *ptr);
 361
 362  free(list);
 363
 364 }
 365
 366
 367 int main(void)
 368 {
 369   /* Clean the server before beginning testing */
 370   flush_test();
 371   init_test();
 372   allocation_test();
 373   connection_test();
 374   set_test();
 375   add_test();
 376   replace_test();
 377   flush_test();
 378   delete_test();
 379   flush_test();
 380   get_test();
 381   get_test2();
 382   get_test3();
 383   stats_hostname_test();
 384
 385   increment_test();
 386   decrement_test();
 387   quit_test();
 388 //  mget_test();
 389   get_stats_keys();
 390
 391   /* Clean up whatever we might have left */
 392   flush_test();
 393   return 0;
 394 }