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   assert(memc);
  32   rc= memcached_server_add(memc, "localhost", 0);
  33   assert(rc == MEMCACHED_SUCCESS);
  34   assert(memc);
  35   memcached_deinit(memc);
  36 }
  37
  38 void error_test(void)
  39 {
  40   memcached_st *memc;
  41   memc= memcached_init(NULL);
  42   memcached_return rc;
  43
  44   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  45   {
  46     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
  47   }
  48
  49   assert(memc);
  50   memcached_deinit(memc);
  51 }
  52
  53 void set_test(void)
  54 {
  55   memcached_st *memc;
  56   memcached_return rc;
  57   char *key= "foo";
  58   char *value= "when we sanitize";
  59
  60   memc= memcached_init(NULL);
  61   assert(memc);
  62   rc= memcached_server_add(memc, "localhost", 0);
  63   assert(rc == MEMCACHED_SUCCESS);
  64   rc= memcached_set(memc, key, strlen(key),
  65                     value, strlen(value),
  66                     (time_t)0, (uint16_t)0);
  67   assert(rc == MEMCACHED_SUCCESS);
  68
  69   memcached_deinit(memc);
  70 }
  71
  72 void add_test(void)
  73 {
  74   memcached_st *memc;
  75   memcached_return rc;
  76   char *key= "foo";
  77   char *value= "when we sanitize";
  78
  79   memc= memcached_init(NULL);
  80   assert(memc);
  81   rc= memcached_server_add(memc, "localhost", 0);
  82   assert(rc == MEMCACHED_SUCCESS);
  83   rc= memcached_add(memc, key, strlen(key),
  84                     value, strlen(value),
  85                     (time_t)0, (uint16_t)0);
  86   assert(rc == MEMCACHED_NOTSTORED);
  87
  88   memcached_deinit(memc);
  89 }
  90
  91 void replace_test(void)
  92 {
  93   memcached_st *memc;
  94   memcached_return rc;
  95   char *key= "foo";
  96   char *value= "when we sanitize";
  97
  98   memc= memcached_init(NULL);
  99   assert(memc);
 100   rc= memcached_server_add(memc, "localhost", 0);
 101   assert(rc == MEMCACHED_SUCCESS);
 102   rc= memcached_replace(memc, key, strlen(key),
 103                     value, strlen(value),
 104                     (time_t)0, (uint16_t)0);
 105   assert(rc == MEMCACHED_SUCCESS);
 106
 107   memcached_deinit(memc);
 108 }
 109
 110 void delete_test(void)
 111 {
 112   memcached_st *memc;
 113   memcached_return rc;
 114   char *key= "foo";
 115   char *value= "when we sanitize";
 116
 117   memc= memcached_init(NULL);
 118   assert(memc);
 119   rc= memcached_server_add(memc, "localhost", 0);
 120   assert(rc == MEMCACHED_SUCCESS);
 121   rc= memcached_set(memc, key, strlen(key),
 122                     value, strlen(value),
 123                     (time_t)0, (uint16_t)0);
 124   assert(rc == MEMCACHED_SUCCESS);
 125
 126   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 127   assert(rc == MEMCACHED_SUCCESS);
 128
 129   memcached_deinit(memc);
 130 }
 131
 132 void flush_test(void)
 133 {
 134   memcached_st *memc;
 135   memcached_return rc;
 136
 137   memc= memcached_init(NULL);
 138   assert(memc);
 139   rc= memcached_server_add(memc, "localhost", 0);
 140   assert(rc == MEMCACHED_SUCCESS);
 141   rc= memcached_flush(memc, 0);
 142   assert(rc == MEMCACHED_SUCCESS);
 143
 144   memcached_deinit(memc);
 145 }
 146
 147 void get_test(void)
 148 {
 149   memcached_st *memc;
 150   memcached_return rc;
 151   char *key= "foo";
 152   char *string;
 153   size_t string_length;
 154   uint16_t flags;
 155
 156   memc= memcached_init(NULL);
 157   assert(memc);
 158   rc= memcached_server_add(memc, "localhost", 0);
 159   assert(rc == MEMCACHED_SUCCESS);
 160
 161   string= memcached_get(memc, key, strlen(key),
 162                         &string_length, &flags, &rc);
 163
 164   assert(rc == MEMCACHED_NOTFOUND);
 165   assert(string_length ==  0);
 166   assert(!string);
 167
 168   memcached_deinit(memc);
 169 }
 170
 171 void get_test2(void)
 172 {
 173   memcached_st *memc;
 174   memcached_return rc;
 175   char *key= "foo";
 176   char *value= "when we sanitize";
 177   char *string;
 178   size_t string_length;
 179   uint16_t flags;
 180
 181   memc= memcached_init(NULL);
 182   assert(memc);
 183   rc= memcached_server_add(memc, "localhost", 0);
 184   assert(rc == MEMCACHED_SUCCESS);
 185
 186   rc= memcached_set(memc, key, strlen(key),
 187                     value, strlen(value),
 188                     (time_t)0, (uint16_t)0);
 189   assert(rc == MEMCACHED_SUCCESS);
 190
 191   string= memcached_get(memc, key, strlen(key),
 192                         &string_length, &flags, &rc);
 193
 194   assert(string);
 195   assert(rc == MEMCACHED_SUCCESS);
 196   assert(string_length == strlen(value));
 197   assert(!memcmp(string, value, string_length));
 198
 199   free(string);
 200
 201   memcached_deinit(memc);
 202 }
 203
 204 void get_test3(void)
 205 {
 206   memcached_st *memc;
 207   memcached_return rc;
 208   char *key= "foo";
 209   char *value;
 210   size_t value_length= 8191;
 211   char *string;
 212   size_t string_length;
 213   uint16_t flags;
 214   int i;
 215
 216   value = (char*) malloc(value_length);
 217   for (i=0; i<value_length; i++)
 218     value[i] = (char) (i % 127);
 219
 220   memc= memcached_init(NULL);
 221   assert(memc);
 222   rc= memcached_server_add(memc, "localhost", 0);
 223   assert(rc == MEMCACHED_SUCCESS);
 224
 225   rc= memcached_set(memc, key, strlen(key),
 226                     value, value_length,
 227                     (time_t)0, (uint16_t)0);
 228   assert(rc == MEMCACHED_SUCCESS);
 229
 230   string= memcached_get(memc, key, strlen(key),
 231                         &string_length, &flags, &rc);
 232
 233   assert(string_length == value_length);
 234   assert(!memcmp(string, value, string_length));
 235
 236   free(string);
 237   free(value);
 238
 239   memcached_deinit(memc);
 240 }
 241
 242 void stats_servername_test(void)
 243 {
 244   memcached_return rc;
 245   memcached_stat_st stat;
 246   rc= memcached_stat_servername(&stat, NULL,
 247                                  "localhost",
 248                                  MEMCACHED_DEFAULT_PORT);
 249 }
 250
 251 void increment_test(void)
 252 {
 253   memcached_st *memc;
 254   unsigned int new_number;
 255   memcached_return rc;
 256   char *key= "number";
 257   char *value= "0";
 258
 259   memc= memcached_init(NULL);
 260   assert(memc);
 261   rc= memcached_server_add(memc, "localhost", 0);
 262   assert(rc == MEMCACHED_SUCCESS);
 263
 264   rc= memcached_set(memc, key, strlen(key),
 265                     value, strlen(value),
 266                     (time_t)0, (uint16_t)0);
 267   assert(rc == MEMCACHED_SUCCESS);
 268
 269   rc= memcached_increment(memc, key, strlen(key),
 270                           1, &new_number);
 271   assert(rc == MEMCACHED_SUCCESS);
 272   assert(new_number == 1);
 273
 274   rc= memcached_increment(memc, key, strlen(key),
 275                           1, &new_number);
 276   assert(rc == MEMCACHED_SUCCESS);
 277   assert(new_number == 2);
 278
 279   memcached_deinit(memc);
 280 }
 281
 282 void decrement_test(void)
 283 {
 284   memcached_st *memc;
 285   unsigned int new_number;
 286   memcached_return rc;
 287   char *key= "number";
 288   char *value= "3";
 289
 290   memc= memcached_init(NULL);
 291   assert(memc);
 292   rc= memcached_server_add(memc, "localhost", 0);
 293   assert(rc == MEMCACHED_SUCCESS);
 294
 295   rc= memcached_set(memc, key, strlen(key),
 296                     value, strlen(value),
 297                     (time_t)0, (uint16_t)0);
 298   assert(rc == MEMCACHED_SUCCESS);
 299
 300   rc= memcached_decrement(memc, key, strlen(key),
 301                           1, &new_number);
 302   assert(rc == MEMCACHED_SUCCESS);
 303   assert(new_number == 2);
 304
 305   rc= memcached_decrement(memc, key, strlen(key),
 306                           1, &new_number);
 307   assert(rc == MEMCACHED_SUCCESS);
 308   assert(new_number == 1);
 309
 310   memcached_deinit(memc);
 311 }
 312
 313 void quit_test(void)
 314 {
 315   memcached_st *memc;
 316   memcached_return rc;
 317   char *key= "fudge";
 318   char *value= "sanford and sun";
 319
 320   memc= memcached_init(NULL);
 321   assert(memc);
 322   rc= memcached_server_add(memc, "localhost", 0);
 323   assert(rc == MEMCACHED_SUCCESS);
 324
 325   rc= memcached_set(memc, key, strlen(key),
 326                     value, strlen(value),
 327                     (time_t)10, (uint16_t)3);
 328   assert(rc == MEMCACHED_SUCCESS);
 329   memcached_quit(memc);
 330
 331   rc= memcached_set(memc, key, strlen(key),
 332                     value, strlen(value),
 333                     (time_t)50, (uint16_t)9);
 334   assert(rc == MEMCACHED_SUCCESS);
 335
 336   memcached_deinit(memc);
 337 }
 338
 339 void mget_test(void)
 340 {
 341   memcached_st *memc;
 342   memcached_return rc;
 343   char *keys[]= {"fudge", "son", "food"};
 344   size_t key_length[]= {5, 3, 4};
 345   unsigned int x;
 346   uint16_t flags;
 347
 348   char return_key[MEMCACHED_MAX_KEY];
 349   size_t return_key_length;
 350   char *return_value;
 351   size_t return_value_length;
 352
 353   memc= memcached_init(NULL);
 354   assert(memc);
 355   rc= memcached_server_add(memc, "localhost", 0);
 356   assert(rc == MEMCACHED_SUCCESS);
 357
 358   /* We need to empty the server before continueing test */
 359   rc= memcached_flush(memc, 0);
 360   assert(rc == MEMCACHED_SUCCESS);
 361
 362   rc= memcached_mget(memc, keys, key_length, 3);
 363   assert(rc == MEMCACHED_SUCCESS);
 364
 365   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 366                       &return_value_length, &flags, &rc)) != NULL)
 367   {
 368     assert(return_value);
 369   }
 370   assert(!return_value);
 371   assert(return_value_length == 0);
 372   assert(rc == MEMCACHED_NOTFOUND);
 373
 374   for (x= 0; x < 3; x++)
 375   {
 376     rc= memcached_set(memc, keys[x], key_length[x],
 377                       keys[x], key_length[x],
 378                       (time_t)50, (uint16_t)9);
 379     assert(rc == MEMCACHED_SUCCESS);
 380   }
 381
 382   rc= memcached_mget(memc, keys, key_length, 3);
 383   assert(rc == MEMCACHED_SUCCESS);
 384
 385   x= 0;
 386   while (return_value= memcached_fetch(memc, return_key, &return_key_length,
 387                       &return_value_length, &flags, &rc))
 388   {
 389     assert(return_value);
 390     assert(rc == MEMCACHED_SUCCESS);
 391     assert(key_length[x] == return_value_length);
 392     assert(!memcmp(return_value, keys[x], return_value_length));
 393     free(return_value);
 394     x++;
 395   }
 396
 397   memcached_deinit(memc);
 398 }
 399
 400 void get_stats_keys(void)
 401 {
 402  char **list;
 403  char **ptr;
 404  memcached_st *memc;
 405  memcached_stat_st stat;
 406  memcached_return rc;
 407
 408  memc= memcached_init(NULL);
 409  assert(memc);
 410
 411  list= memcached_stat_get_keys(memc, &stat, &rc);
 412  assert(rc == MEMCACHED_SUCCESS);
 413  for (ptr= list; *ptr; ptr++)
 414    printf("Found key %s\n", *ptr);
 415
 416  free(list);
 417  memcached_deinit(memc);
 418 }
 419
 420 void get_stats(void)
 421 {
 422  unsigned int x;
 423  char **list;
 424  char **ptr;
 425  memcached_return rc;
 426  memcached_st *memc;
 427  memcached_stat_st *stat;
 428
 429  memc= memcached_init(NULL);
 430  assert(memc);
 431  rc= memcached_server_add(memc, "localhost", 0);
 432  assert(rc == MEMCACHED_SUCCESS);
 433
 434  stat= memcached_stat(memc, NULL, &rc);
 435  assert(rc == MEMCACHED_SUCCESS);
 436
 437  assert(rc == MEMCACHED_SUCCESS);
 438  assert(stat);
 439
 440  for (x= 0; x < memcached_server_count(memc); x++)
 441  {
 442    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 443    assert(rc == MEMCACHED_SUCCESS);
 444    for (ptr= list; *ptr; ptr++)
 445      printf("Found key %s\n", *ptr);
 446
 447    free(list);
 448  }
 449
 450  free(stat);
 451  memcached_deinit(memc);
 452 }
 453
 454 void get_stats_multiple(void)
 455 {
 456  unsigned int x;
 457  char **list;
 458  char **ptr;
 459  memcached_return rc;
 460  memcached_st *memc;
 461  memcached_stat_st *stat;
 462
 463  memc= memcached_init(NULL);
 464  assert(memc);
 465  rc= memcached_server_add(memc, "localhost", 0);
 466  assert(rc == MEMCACHED_SUCCESS);
 467  rc= memcached_server_add(memc, "localhost", 5555);
 468  assert(rc == MEMCACHED_SUCCESS);
 469
 470  stat= memcached_stat(memc, NULL, &rc);
 471  assert(rc == MEMCACHED_SUCCESS);
 472
 473  assert(rc == MEMCACHED_SUCCESS);
 474  assert(stat);
 475
 476  for (x= 0; x < memcached_server_count(memc); x++)
 477  {
 478    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 479    assert(rc == MEMCACHED_SUCCESS);
 480    for (ptr= list; *ptr; ptr++)
 481      printf("Found key %s\n", *ptr);
 482
 483    free(list);
 484  }
 485
 486  free(stat);
 487  memcached_deinit(memc);
 488 }
 489
 490
 491 int main(int argc, char argvp[])
 492 {
 493   /* Clean the server before beginning testing */
 494   flush_test();
 495   init_test();
 496   allocation_test();
 497   connection_test();
 498   error_test();
 499   set_test();
 500   add_test();
 501   replace_test();
 502   flush_test();
 503   delete_test();
 504   flush_test();
 505   get_test();
 506   get_test2();
 507   get_test3();
 508   stats_servername_test();
 509
 510   increment_test();
 511   decrement_test();
 512   quit_test();
 513   mget_test();
 514   get_stats();
 515
 516   /* The multiple tests */
 517   if (argc == 2)
 518   {
 519     get_stats_multiple();
 520   }
 521   get_stats_keys();
 522
 523   /* Clean up whatever we might have left */
 524   flush_test();
 525   return 0;
 526 }