git.m6w6.name Git - m6w6/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 x;
 215
 216   value = (char*)malloc(value_length);
 217   assert(value);
 218
 219   for (x= 0; x < value_length; x++)
 220     value[x] = (char) (x % 127);
 221
 222   memc= memcached_init(NULL);
 223   assert(memc);
 224   rc= memcached_server_add(memc, "localhost", 0);
 225   assert(rc == MEMCACHED_SUCCESS);
 226
 227   rc= memcached_set(memc, key, strlen(key),
 228                     value, value_length,
 229                     (time_t)0, (uint16_t)0);
 230   assert(rc == MEMCACHED_SUCCESS);
 231
 232   string= memcached_get(memc, key, strlen(key),
 233                         &string_length, &flags, &rc);
 234
 235   assert(rc == MEMCACHED_SUCCESS);
 236   assert(string);
 237   assert(string_length == value_length);
 238   assert(!memcmp(string, value, string_length));
 239
 240   free(string);
 241   free(value);
 242
 243   memcached_deinit(memc);
 244 }
 245
 246 void stats_servername_test(void)
 247 {
 248   memcached_return rc;
 249   memcached_stat_st stat;
 250   rc= memcached_stat_servername(&stat, NULL,
 251                                  "localhost",
 252                                  MEMCACHED_DEFAULT_PORT);
 253 }
 254
 255 void increment_test(void)
 256 {
 257   memcached_st *memc;
 258   unsigned int new_number;
 259   memcached_return rc;
 260   char *key= "number";
 261   char *value= "0";
 262
 263   memc= memcached_init(NULL);
 264   assert(memc);
 265   rc= memcached_server_add(memc, "localhost", 0);
 266   assert(rc == MEMCACHED_SUCCESS);
 267
 268   rc= memcached_set(memc, key, strlen(key),
 269                     value, strlen(value),
 270                     (time_t)0, (uint16_t)0);
 271   assert(rc == MEMCACHED_SUCCESS);
 272
 273   rc= memcached_increment(memc, key, strlen(key),
 274                           1, &new_number);
 275   assert(rc == MEMCACHED_SUCCESS);
 276   assert(new_number == 1);
 277
 278   rc= memcached_increment(memc, key, strlen(key),
 279                           1, &new_number);
 280   assert(rc == MEMCACHED_SUCCESS);
 281   assert(new_number == 2);
 282
 283   memcached_deinit(memc);
 284 }
 285
 286 void decrement_test(void)
 287 {
 288   memcached_st *memc;
 289   unsigned int new_number;
 290   memcached_return rc;
 291   char *key= "number";
 292   char *value= "3";
 293
 294   memc= memcached_init(NULL);
 295   assert(memc);
 296   rc= memcached_server_add(memc, "localhost", 0);
 297   assert(rc == MEMCACHED_SUCCESS);
 298
 299   rc= memcached_set(memc, key, strlen(key),
 300                     value, strlen(value),
 301                     (time_t)0, (uint16_t)0);
 302   assert(rc == MEMCACHED_SUCCESS);
 303
 304   rc= memcached_decrement(memc, key, strlen(key),
 305                           1, &new_number);
 306   assert(rc == MEMCACHED_SUCCESS);
 307   assert(new_number == 2);
 308
 309   rc= memcached_decrement(memc, key, strlen(key),
 310                           1, &new_number);
 311   assert(rc == MEMCACHED_SUCCESS);
 312   assert(new_number == 1);
 313
 314   memcached_deinit(memc);
 315 }
 316
 317 void quit_test(void)
 318 {
 319   memcached_st *memc;
 320   memcached_return rc;
 321   char *key= "fudge";
 322   char *value= "sanford and sun";
 323
 324   memc= memcached_init(NULL);
 325   assert(memc);
 326   rc= memcached_server_add(memc, "localhost", 0);
 327   assert(rc == MEMCACHED_SUCCESS);
 328
 329   rc= memcached_set(memc, key, strlen(key),
 330                     value, strlen(value),
 331                     (time_t)10, (uint16_t)3);
 332   assert(rc == MEMCACHED_SUCCESS);
 333   memcached_quit(memc);
 334
 335   rc= memcached_set(memc, key, strlen(key),
 336                     value, strlen(value),
 337                     (time_t)50, (uint16_t)9);
 338   assert(rc == MEMCACHED_SUCCESS);
 339
 340   memcached_deinit(memc);
 341 }
 342
 343 void mget_test(void)
 344 {
 345   memcached_st *memc;
 346   memcached_return rc;
 347   char *keys[]= {"fudge", "son", "food"};
 348   size_t key_length[]= {5, 3, 4};
 349   unsigned int x;
 350   uint16_t flags;
 351
 352   char return_key[MEMCACHED_MAX_KEY];
 353   size_t return_key_length;
 354   char *return_value;
 355   size_t return_value_length;
 356
 357   memc= memcached_init(NULL);
 358   assert(memc);
 359   rc= memcached_server_add(memc, "localhost", 0);
 360   assert(rc == MEMCACHED_SUCCESS);
 361
 362   /* We need to empty the server before continueing test */
 363   rc= memcached_flush(memc, 0);
 364   assert(rc == MEMCACHED_SUCCESS);
 365
 366   rc= memcached_mget(memc, keys, key_length, 3);
 367   assert(rc == MEMCACHED_SUCCESS);
 368
 369   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 370                       &return_value_length, &flags, &rc)) != NULL)
 371   {
 372     assert(return_value);
 373   }
 374   assert(!return_value);
 375   assert(return_value_length == 0);
 376   assert(rc == MEMCACHED_NOTFOUND);
 377
 378   for (x= 0; x < 3; x++)
 379   {
 380     rc= memcached_set(memc, keys[x], key_length[x],
 381                       keys[x], key_length[x],
 382                       (time_t)50, (uint16_t)9);
 383     assert(rc == MEMCACHED_SUCCESS);
 384   }
 385
 386   rc= memcached_mget(memc, keys, key_length, 3);
 387   assert(rc == MEMCACHED_SUCCESS);
 388
 389   x= 0;
 390   while (return_value= memcached_fetch(memc, return_key, &return_key_length,
 391                       &return_value_length, &flags, &rc))
 392   {
 393     assert(return_value);
 394     assert(rc == MEMCACHED_SUCCESS);
 395     assert(key_length[x] == return_value_length);
 396     assert(!memcmp(return_value, keys[x], return_value_length));
 397     free(return_value);
 398     x++;
 399   }
 400
 401   memcached_deinit(memc);
 402 }
 403
 404 void get_stats_keys(void)
 405 {
 406  char **list;
 407  char **ptr;
 408  memcached_st *memc;
 409  memcached_stat_st stat;
 410  memcached_return rc;
 411
 412  memc= memcached_init(NULL);
 413  assert(memc);
 414
 415  list= memcached_stat_get_keys(memc, &stat, &rc);
 416  assert(rc == MEMCACHED_SUCCESS);
 417  for (ptr= list; *ptr; ptr++)
 418    printf("Found key %s\n", *ptr);
 419
 420  free(list);
 421  memcached_deinit(memc);
 422 }
 423
 424 void get_stats(void)
 425 {
 426  unsigned int x;
 427  char **list;
 428  char **ptr;
 429  memcached_return rc;
 430  memcached_st *memc;
 431  memcached_stat_st *stat;
 432
 433  memc= memcached_init(NULL);
 434  assert(memc);
 435  rc= memcached_server_add(memc, "localhost", 0);
 436  assert(rc == MEMCACHED_SUCCESS);
 437
 438  stat= memcached_stat(memc, NULL, &rc);
 439  assert(rc == MEMCACHED_SUCCESS);
 440
 441  assert(rc == MEMCACHED_SUCCESS);
 442  assert(stat);
 443
 444  for (x= 0; x < memcached_server_count(memc); x++)
 445  {
 446    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 447    assert(rc == MEMCACHED_SUCCESS);
 448    for (ptr= list; *ptr; ptr++)
 449      printf("Found key %s\n", *ptr);
 450
 451    free(list);
 452  }
 453
 454  free(stat);
 455  memcached_deinit(memc);
 456 }
 457
 458 void get_stats_multiple(void)
 459 {
 460  unsigned int x;
 461  char **list;
 462  char **ptr;
 463  memcached_return rc;
 464  memcached_st *memc;
 465  memcached_stat_st *stat;
 466
 467  memc= memcached_init(NULL);
 468  assert(memc);
 469  rc= memcached_server_add(memc, "localhost", 0);
 470  assert(rc == MEMCACHED_SUCCESS);
 471  rc= memcached_server_add(memc, "localhost", 5555);
 472  assert(rc == MEMCACHED_SUCCESS);
 473
 474  stat= memcached_stat(memc, NULL, &rc);
 475  assert(rc == MEMCACHED_SUCCESS);
 476
 477  assert(rc == MEMCACHED_SUCCESS);
 478  assert(stat);
 479
 480  for (x= 0; x < memcached_server_count(memc); x++)
 481  {
 482    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 483    assert(rc == MEMCACHED_SUCCESS);
 484    for (ptr= list; *ptr; ptr++)
 485      printf("Found key %s\n", *ptr);
 486
 487    free(list);
 488  }
 489
 490  free(stat);
 491  memcached_deinit(memc);
 492 }
 493
 494
 495 int main(int argc, char argvp[])
 496 {
 497   /* Clean the server before beginning testing */
 498   flush_test();
 499   init_test();
 500   allocation_test();
 501   connection_test();
 502   error_test();
 503   set_test();
 504   add_test();
 505   replace_test();
 506   flush_test();
 507   delete_test();
 508   flush_test();
 509   get_test();
 510   get_test2();
 511   get_test3();
 512   stats_servername_test();
 513
 514   increment_test();
 515   decrement_test();
 516   quit_test();
 517   mget_test();
 518   get_stats();
 519
 520   /* The multiple tests */
 521   if (argc == 2)
 522   {
 523     get_stats_multiple();
 524   }
 525   get_stats_keys();
 526
 527   /* Clean up whatever we might have left */
 528   flush_test();
 529   return 0;
 530 }