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_create(&memc);
  15   memcached_free(&memc);
  16 }
  17
  18 void allocation_test(void)
  19 {
  20   memcached_st *memc;
  21   memc= memcached_create(NULL);
  22   assert(memc);
  23   memcached_free(memc);
  24 }
  25
  26 void connection_test(void)
  27 {
  28   memcached_return rc;
  29   memcached_st *memc;
  30   memc= memcached_create(NULL);
  31   assert(memc);
  32   rc= memcached_server_add(memc, "localhost", 0);
  33   assert(rc == MEMCACHED_SUCCESS);
  34   assert(memc);
  35   memcached_free(memc);
  36 }
  37
  38 void error_test(void)
  39 {
  40   memcached_st *memc;
  41   memc= memcached_create(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_free(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_create(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_free(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_create(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_free(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_create(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_free(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_create(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_free(memc);
 130 }
 131
 132 void flush_test(void)
 133 {
 134   memcached_st *memc;
 135   memcached_return rc;
 136
 137   memc= memcached_create(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_free(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_create(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_free(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_create(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_free(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_create(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_free(memc);
 244 }
 245
 246 void get_test4(void)
 247 {
 248   memcached_st *memc;
 249   memcached_return rc;
 250   char *key= "foo";
 251   char *value;
 252   size_t value_length= 8191;
 253   char *string;
 254   size_t string_length;
 255   uint16_t flags;
 256   int x;
 257
 258   value = (char*)malloc(value_length);
 259   assert(value);
 260
 261   for (x= 0; x < value_length; x++)
 262     value[x] = (char) (x % 127);
 263
 264   memc= memcached_create(NULL);
 265   assert(memc);
 266   rc= memcached_server_add(memc, "localhost", 0);
 267   assert(rc == MEMCACHED_SUCCESS);
 268
 269   rc= memcached_set(memc, key, strlen(key),
 270                     value, value_length,
 271                     (time_t)0, (uint16_t)0);
 272   assert(rc == MEMCACHED_SUCCESS);
 273
 274   for (x= 0; x < 10; x++)
 275   {
 276     string= memcached_get(memc, key, strlen(key),
 277                           &string_length, &flags, &rc);
 278
 279     assert(rc == MEMCACHED_SUCCESS);
 280     assert(string);
 281     assert(string_length == value_length);
 282     assert(!memcmp(string, value, string_length));
 283     free(string);
 284   }
 285
 286   free(value);
 287
 288   memcached_free(memc);
 289 }
 290
 291 void stats_servername_test(void)
 292 {
 293   memcached_return rc;
 294   memcached_stat_st stat;
 295   rc= memcached_stat_servername(&stat, NULL,
 296                                  "localhost",
 297                                  MEMCACHED_DEFAULT_PORT);
 298 }
 299
 300 void increment_test(void)
 301 {
 302   memcached_st *memc;
 303   unsigned int new_number;
 304   memcached_return rc;
 305   char *key= "number";
 306   char *value= "0";
 307
 308   memc= memcached_create(NULL);
 309   assert(memc);
 310   rc= memcached_server_add(memc, "localhost", 0);
 311   assert(rc == MEMCACHED_SUCCESS);
 312
 313   rc= memcached_set(memc, key, strlen(key),
 314                     value, strlen(value),
 315                     (time_t)0, (uint16_t)0);
 316   assert(rc == MEMCACHED_SUCCESS);
 317
 318   rc= memcached_increment(memc, key, strlen(key),
 319                           1, &new_number);
 320   assert(rc == MEMCACHED_SUCCESS);
 321   assert(new_number == 1);
 322
 323   rc= memcached_increment(memc, key, strlen(key),
 324                           1, &new_number);
 325   assert(rc == MEMCACHED_SUCCESS);
 326   assert(new_number == 2);
 327
 328   memcached_free(memc);
 329 }
 330
 331 void decrement_test(void)
 332 {
 333   memcached_st *memc;
 334   unsigned int new_number;
 335   memcached_return rc;
 336   char *key= "number";
 337   char *value= "3";
 338
 339   memc= memcached_create(NULL);
 340   assert(memc);
 341   rc= memcached_server_add(memc, "localhost", 0);
 342   assert(rc == MEMCACHED_SUCCESS);
 343
 344   rc= memcached_set(memc, key, strlen(key),
 345                     value, strlen(value),
 346                     (time_t)0, (uint16_t)0);
 347   assert(rc == MEMCACHED_SUCCESS);
 348
 349   rc= memcached_decrement(memc, key, strlen(key),
 350                           1, &new_number);
 351   assert(rc == MEMCACHED_SUCCESS);
 352   assert(new_number == 2);
 353
 354   rc= memcached_decrement(memc, key, strlen(key),
 355                           1, &new_number);
 356   assert(rc == MEMCACHED_SUCCESS);
 357   assert(new_number == 1);
 358
 359   memcached_free(memc);
 360 }
 361
 362 void quit_test(void)
 363 {
 364   memcached_st *memc;
 365   memcached_return rc;
 366   char *key= "fudge";
 367   char *value= "sanford and sun";
 368
 369   memc= memcached_create(NULL);
 370   assert(memc);
 371   rc= memcached_server_add(memc, "localhost", 0);
 372   assert(rc == MEMCACHED_SUCCESS);
 373
 374   rc= memcached_set(memc, key, strlen(key),
 375                     value, strlen(value),
 376                     (time_t)10, (uint16_t)3);
 377   assert(rc == MEMCACHED_SUCCESS);
 378   memcached_quit(memc);
 379
 380   rc= memcached_set(memc, key, strlen(key),
 381                     value, strlen(value),
 382                     (time_t)50, (uint16_t)9);
 383   assert(rc == MEMCACHED_SUCCESS);
 384
 385   memcached_free(memc);
 386 }
 387
 388 void mget_test(void)
 389 {
 390   memcached_st *memc;
 391   memcached_return rc;
 392   char *keys[]= {"fudge", "son", "food"};
 393   size_t key_length[]= {5, 3, 4};
 394   unsigned int x;
 395   uint16_t flags;
 396
 397   char return_key[MEMCACHED_MAX_KEY];
 398   size_t return_key_length;
 399   char *return_value;
 400   size_t return_value_length;
 401
 402   memc= memcached_create(NULL);
 403   assert(memc);
 404   rc= memcached_server_add(memc, "localhost", 0);
 405   assert(rc == MEMCACHED_SUCCESS);
 406
 407   /* We need to empty the server before continueing test */
 408   rc= memcached_flush(memc, 0);
 409   assert(rc == MEMCACHED_SUCCESS);
 410
 411   rc= memcached_mget(memc, keys, key_length, 3);
 412   assert(rc == MEMCACHED_SUCCESS);
 413
 414   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 415                       &return_value_length, &flags, &rc)) != NULL)
 416   {
 417     assert(return_value);
 418   }
 419   assert(!return_value);
 420   assert(return_value_length == 0);
 421   assert(rc == MEMCACHED_NOTFOUND);
 422
 423   for (x= 0; x < 3; x++)
 424   {
 425     rc= memcached_set(memc, keys[x], key_length[x],
 426                       keys[x], key_length[x],
 427                       (time_t)50, (uint16_t)9);
 428     assert(rc == MEMCACHED_SUCCESS);
 429   }
 430
 431   rc= memcached_mget(memc, keys, key_length, 3);
 432   assert(rc == MEMCACHED_SUCCESS);
 433
 434   x= 0;
 435   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 436                                         &return_value_length, &flags, &rc)))
 437   {
 438     assert(return_value);
 439     assert(rc == MEMCACHED_SUCCESS);
 440     assert(key_length[x] == return_value_length);
 441     assert(!memcmp(return_value, keys[x], return_value_length));
 442     free(return_value);
 443     x++;
 444   }
 445
 446   memcached_free(memc);
 447 }
 448
 449 void get_stats_keys(void)
 450 {
 451  char **list;
 452  char **ptr;
 453  memcached_st *memc;
 454  memcached_stat_st stat;
 455  memcached_return rc;
 456
 457  memc= memcached_create(NULL);
 458  assert(memc);
 459
 460  list= memcached_stat_get_keys(memc, &stat, &rc);
 461  assert(rc == MEMCACHED_SUCCESS);
 462  for (ptr= list; *ptr; ptr++)
 463    printf("Found key %s\n", *ptr);
 464
 465  free(list);
 466  memcached_free(memc);
 467 }
 468
 469 void get_stats(void)
 470 {
 471  unsigned int x;
 472  char **list;
 473  char **ptr;
 474  memcached_return rc;
 475  memcached_st *memc;
 476  memcached_stat_st *stat;
 477
 478  memc= memcached_create(NULL);
 479  assert(memc);
 480  rc= memcached_server_add(memc, "localhost", 0);
 481  assert(rc == MEMCACHED_SUCCESS);
 482
 483  stat= memcached_stat(memc, NULL, &rc);
 484  assert(rc == MEMCACHED_SUCCESS);
 485
 486  assert(rc == MEMCACHED_SUCCESS);
 487  assert(stat);
 488
 489  for (x= 0; x < memcached_server_count(memc); x++)
 490  {
 491    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 492    assert(rc == MEMCACHED_SUCCESS);
 493    for (ptr= list; *ptr; ptr++)
 494      printf("Found key %s\n", *ptr);
 495
 496    free(list);
 497  }
 498
 499  free(stat);
 500  memcached_free(memc);
 501 }
 502
 503 void get_stats_multiple(void)
 504 {
 505  unsigned int x;
 506  char **list;
 507  char **ptr;
 508  memcached_return rc;
 509  memcached_st *memc;
 510  memcached_stat_st *stat;
 511
 512  memc= memcached_create(NULL);
 513  assert(memc);
 514  rc= memcached_server_add(memc, "localhost", 0);
 515  assert(rc == MEMCACHED_SUCCESS);
 516  rc= memcached_server_add(memc, "localhost", 5555);
 517  assert(rc == MEMCACHED_SUCCESS);
 518
 519  stat= memcached_stat(memc, NULL, &rc);
 520  assert(rc == MEMCACHED_SUCCESS);
 521
 522  assert(rc == MEMCACHED_SUCCESS);
 523  assert(stat);
 524
 525  for (x= 0; x < memcached_server_count(memc); x++)
 526  {
 527    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 528    assert(rc == MEMCACHED_SUCCESS);
 529    for (ptr= list; *ptr; ptr++)
 530      printf("Found key %s\n", *ptr);
 531
 532    free(list);
 533  }
 534
 535  free(stat);
 536  memcached_free(memc);
 537 }
 538
 539 void add_host_test(void)
 540 {
 541   unsigned int x;
 542   memcached_st *memc;
 543   memcached_server_st *servers;
 544   memcached_return rc;
 545   char servername[]= "0.example.com";
 546
 547   memc= memcached_create(NULL);
 548   assert(memc);
 549   rc= memcached_server_add(memc, "localhost", 0);
 550   assert(rc == MEMCACHED_SUCCESS);
 551
 552   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 553   assert(servers);
 554   assert(1 == memcached_server_list_count(servers));
 555
 556   for (x= 2; x < 20; x++)
 557   {
 558     char buffer[SMALL_STRING_LEN];
 559
 560     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 561     servers= memcached_server_list_append(servers, buffer, 401,
 562                                      &rc);
 563     assert(rc == MEMCACHED_SUCCESS);
 564     assert(x == memcached_server_list_count(servers));
 565   }
 566
 567   rc= memcached_server_push(memc, servers);
 568   assert(rc == MEMCACHED_SUCCESS);
 569   rc= memcached_server_push(memc, servers);
 570   assert(rc == MEMCACHED_SUCCESS);
 571
 572   memcached_server_list_free(servers);
 573   memcached_free(memc);
 574 }
 575
 576 void add_host_test1(void)
 577 {
 578   unsigned int x;
 579   memcached_st *memc;
 580   memcached_server_st *servers;
 581   memcached_return rc;
 582   char servername[]= "0.example.com";
 583
 584   memc= memcached_create(NULL);
 585   assert(memc);
 586
 587   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 588   assert(servers);
 589   assert(1 == memcached_server_list_count(servers));
 590
 591   for (x= 2; x < 20; x++)
 592   {
 593     char buffer[SMALL_STRING_LEN];
 594
 595     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 596     servers= memcached_server_list_append(servers, buffer, 401,
 597                                      &rc);
 598     assert(rc == MEMCACHED_SUCCESS);
 599     assert(x == memcached_server_list_count(servers));
 600   }
 601
 602   rc= memcached_server_push(memc, servers);
 603   assert(rc == MEMCACHED_SUCCESS);
 604   rc= memcached_server_push(memc, servers);
 605   assert(rc == MEMCACHED_SUCCESS);
 606
 607   memcached_server_list_free(servers);
 608   memcached_free(memc);
 609 }
 610
 611
 612 int main(int argc, char *argv[])
 613 {
 614   /* Clean the server before beginning testing */
 615   flush_test();
 616   init_test();
 617   allocation_test();
 618   connection_test();
 619   error_test();
 620   set_test();
 621   add_test();
 622   replace_test();
 623   flush_test();
 624   delete_test();
 625   flush_test();
 626   get_test();
 627   get_test2();
 628   get_test3();
 629   get_test4();
 630   stats_servername_test();
 631
 632   increment_test();
 633   decrement_test();
 634   quit_test();
 635   mget_test();
 636   get_stats();
 637   add_host_test();
 638
 639   /* The multiple tests */
 640   if (argc == 2)
 641   {
 642     get_stats_multiple();
 643   }
 644   get_stats_keys();
 645
 646   /* Clean up whatever we might have left */
 647   flush_test();
 648   return 0;
 649 }