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