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(memcached_st *not_used)
  11 {
  12   memcached_st memc;
  13
  14   (void)memcached_create(&memc);
  15   memcached_free(&memc);
  16 }
  17
  18 void allocation_test(memcached_st *not_used)
  19 {
  20   memcached_st *memc;
  21   memc= memcached_create(NULL);
  22   assert(memc);
  23   memcached_free(memc);
  24 }
  25
  26 void connection_test(memcached_st *memc)
  27 {
  28   memcached_return rc;
  29
  30   rc= memcached_server_add(memc, "localhost", 0);
  31   assert(rc == MEMCACHED_SUCCESS);
  32 }
  33
  34 void error_test(memcached_st *memc)
  35 {
  36   memcached_return rc;
  37
  38   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  39   {
  40     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
  41   }
  42 }
  43
  44 void set_test(memcached_st *memc)
  45 {
  46   memcached_return rc;
  47   char *key= "foo";
  48   char *value= "when we sanitize";
  49
  50   rc= memcached_set(memc, key, strlen(key),
  51                     value, strlen(value),
  52                     (time_t)0, (uint16_t)0);
  53   assert(rc == MEMCACHED_SUCCESS);
  54 }
  55
  56 void add_test(memcached_st *memc)
  57 {
  58   memcached_return rc;
  59   char *key= "foo";
  60   char *value= "when we sanitize";
  61
  62   rc= memcached_add(memc, key, strlen(key),
  63                     value, strlen(value),
  64                     (time_t)0, (uint16_t)0);
  65   assert(rc == MEMCACHED_NOTSTORED);
  66 }
  67
  68 void replace_test(memcached_st *memc)
  69 {
  70   memcached_return rc;
  71   char *key= "foo";
  72   char *value= "when we sanitize";
  73
  74   rc= memcached_replace(memc, key, strlen(key),
  75                     value, strlen(value),
  76                     (time_t)0, (uint16_t)0);
  77   assert(rc == MEMCACHED_SUCCESS);
  78 }
  79
  80 void delete_test(memcached_st *memc)
  81 {
  82   memcached_return rc;
  83   char *key= "foo";
  84   char *value= "when we sanitize";
  85
  86   rc= memcached_set(memc, key, strlen(key),
  87                     value, strlen(value),
  88                     (time_t)0, (uint16_t)0);
  89   assert(rc == MEMCACHED_SUCCESS);
  90
  91   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
  92   assert(rc == MEMCACHED_SUCCESS);
  93 }
  94
  95 void flush_test(memcached_st *memc)
  96 {
  97   memcached_return rc;
  98
  99   rc= memcached_flush(memc, 0);
 100   assert(rc == MEMCACHED_SUCCESS);
 101 }
 102
 103 void get_test(memcached_st *memc)
 104 {
 105   memcached_return rc;
 106   char *key= "foo";
 107   char *string;
 108   size_t string_length;
 109   uint16_t flags;
 110
 111   string= memcached_get(memc, key, strlen(key),
 112                         &string_length, &flags, &rc);
 113
 114   assert(rc == MEMCACHED_NOTFOUND);
 115   assert(string_length ==  0);
 116   assert(!string);
 117 }
 118
 119 void get_test2(memcached_st *memc)
 120 {
 121   memcached_return rc;
 122   char *key= "foo";
 123   char *value= "when we sanitize";
 124   char *string;
 125   size_t string_length;
 126   uint16_t flags;
 127
 128   rc= memcached_set(memc, key, strlen(key),
 129                     value, strlen(value),
 130                     (time_t)0, (uint16_t)0);
 131   assert(rc == MEMCACHED_SUCCESS);
 132
 133   string= memcached_get(memc, key, strlen(key),
 134                         &string_length, &flags, &rc);
 135
 136   assert(string);
 137   assert(rc == MEMCACHED_SUCCESS);
 138   assert(string_length == strlen(value));
 139   assert(!memcmp(string, value, string_length));
 140
 141   free(string);
 142 }
 143
 144 void set_test2(memcached_st *memc)
 145 {
 146   memcached_return rc;
 147   char *key= "foo";
 148   char *value= "train in the brain";
 149   size_t value_length= strlen(value);
 150   unsigned int x;
 151
 152   for (x= 0; x < 10; x++)
 153   {
 154     rc= memcached_set(memc, key, strlen(key),
 155                       value, value_length,
 156                       (time_t)0, (uint16_t)0);
 157     assert(rc == MEMCACHED_SUCCESS);
 158   }
 159 }
 160
 161 void set_test3(memcached_st *memc)
 162 {
 163   memcached_return rc;
 164   char *key= "foo";
 165   char *value;
 166   size_t value_length= 8191;
 167   unsigned int x;
 168
 169   value = (char*)malloc(value_length);
 170   assert(value);
 171
 172   for (x= 0; x < value_length; x++)
 173     value[x] = (char) (x % 127);
 174
 175   for (x= 0; x < 1; x++)
 176   {
 177     rc= memcached_set(memc, key, strlen(key),
 178                       value, value_length,
 179                       (time_t)0, (uint16_t)0);
 180     assert(rc == MEMCACHED_SUCCESS);
 181   }
 182
 183   free(value);
 184 }
 185
 186 void get_test3(memcached_st *memc)
 187 {
 188   memcached_return rc;
 189   char *key= "foo";
 190   char *value;
 191   size_t value_length= 8191;
 192   char *string;
 193   size_t string_length;
 194   uint16_t flags;
 195   int x;
 196
 197   value = (char*)malloc(value_length);
 198   assert(value);
 199
 200   for (x= 0; x < value_length; x++)
 201     value[x] = (char) (x % 127);
 202
 203   rc= memcached_set(memc, key, strlen(key),
 204                     value, value_length,
 205                     (time_t)0, (uint16_t)0);
 206   assert(rc == MEMCACHED_SUCCESS);
 207
 208   string= memcached_get(memc, key, strlen(key),
 209                         &string_length, &flags, &rc);
 210
 211   WATCHPOINT_ERRNO(memc->my_errno);
 212   WATCHPOINT_ERROR(rc);
 213   assert(rc == MEMCACHED_SUCCESS);
 214   assert(string);
 215   assert(string_length == value_length);
 216   assert(!memcmp(string, value, string_length));
 217
 218   free(string);
 219   free(value);
 220 }
 221
 222 void get_test4(memcached_st *memc)
 223 {
 224   memcached_return rc;
 225   char *key= "foo";
 226   char *value;
 227   size_t value_length= 8191;
 228   char *string;
 229   size_t string_length;
 230   uint16_t flags;
 231   int x;
 232
 233   value = (char*)malloc(value_length);
 234   assert(value);
 235
 236   for (x= 0; x < value_length; x++)
 237     value[x] = (char) (x % 127);
 238
 239   rc= memcached_set(memc, key, strlen(key),
 240                     value, value_length,
 241                     (time_t)0, (uint16_t)0);
 242   assert(rc == MEMCACHED_SUCCESS);
 243
 244   for (x= 0; x < 10; x++)
 245   {
 246     string= memcached_get(memc, key, strlen(key),
 247                           &string_length, &flags, &rc);
 248
 249     assert(rc == MEMCACHED_SUCCESS);
 250     assert(string);
 251     assert(string_length == value_length);
 252     assert(!memcmp(string, value, string_length));
 253     free(string);
 254   }
 255
 256   free(value);
 257 }
 258
 259 void stats_servername_test(memcached_st *memc)
 260 {
 261   memcached_return rc;
 262   memcached_stat_st stat;
 263   rc= memcached_stat_servername(&stat, NULL,
 264                                  "localhost",
 265                                  MEMCACHED_DEFAULT_PORT);
 266 }
 267
 268 void increment_test(memcached_st *memc)
 269 {
 270   unsigned int new_number;
 271   memcached_return rc;
 272   char *key= "number";
 273   char *value= "0";
 274
 275   rc= memcached_set(memc, key, strlen(key),
 276                     value, strlen(value),
 277                     (time_t)0, (uint16_t)0);
 278   assert(rc == MEMCACHED_SUCCESS);
 279
 280   rc= memcached_increment(memc, key, strlen(key),
 281                           1, &new_number);
 282   assert(rc == MEMCACHED_SUCCESS);
 283   assert(new_number == 1);
 284
 285   rc= memcached_increment(memc, key, strlen(key),
 286                           1, &new_number);
 287   assert(rc == MEMCACHED_SUCCESS);
 288   assert(new_number == 2);
 289 }
 290
 291 void decrement_test(memcached_st *memc)
 292 {
 293   unsigned int new_number;
 294   memcached_return rc;
 295   char *key= "number";
 296   char *value= "3";
 297
 298   rc= memcached_set(memc, key, strlen(key),
 299                     value, strlen(value),
 300                     (time_t)0, (uint16_t)0);
 301   assert(rc == MEMCACHED_SUCCESS);
 302
 303   rc= memcached_decrement(memc, key, strlen(key),
 304                           1, &new_number);
 305   assert(rc == MEMCACHED_SUCCESS);
 306   assert(new_number == 2);
 307
 308   rc= memcached_decrement(memc, key, strlen(key),
 309                           1, &new_number);
 310   assert(rc == MEMCACHED_SUCCESS);
 311   assert(new_number == 1);
 312 }
 313
 314 void quit_test(memcached_st *memc)
 315 {
 316   memcached_return rc;
 317   char *key= "fudge";
 318   char *value= "sanford and sun";
 319
 320   rc= memcached_set(memc, key, strlen(key),
 321                     value, strlen(value),
 322                     (time_t)10, (uint16_t)3);
 323   assert(rc == MEMCACHED_SUCCESS);
 324   memcached_quit(memc);
 325
 326   rc= memcached_set(memc, key, strlen(key),
 327                     value, strlen(value),
 328                     (time_t)50, (uint16_t)9);
 329   assert(rc == MEMCACHED_SUCCESS);
 330 }
 331
 332 void mget_test(memcached_st *memc)
 333 {
 334   memcached_return rc;
 335   char *keys[]= {"fudge", "son", "food"};
 336   size_t key_length[]= {5, 3, 4};
 337   unsigned int x;
 338   uint16_t flags;
 339
 340   char return_key[MEMCACHED_MAX_KEY];
 341   size_t return_key_length;
 342   char *return_value;
 343   size_t return_value_length;
 344
 345   /* We need to empty the server before continueing test */
 346   rc= memcached_flush(memc, 0);
 347   assert(rc == MEMCACHED_SUCCESS);
 348
 349   rc= memcached_mget(memc, keys, key_length, 3);
 350   assert(rc == MEMCACHED_SUCCESS);
 351
 352   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 353                       &return_value_length, &flags, &rc)) != NULL)
 354   {
 355     assert(return_value);
 356   }
 357   assert(!return_value);
 358   assert(return_value_length == 0);
 359   assert(rc == MEMCACHED_NOTFOUND);
 360
 361   for (x= 0; x < 3; x++)
 362   {
 363     rc= memcached_set(memc, keys[x], key_length[x],
 364                       keys[x], key_length[x],
 365                       (time_t)50, (uint16_t)9);
 366     assert(rc == MEMCACHED_SUCCESS);
 367   }
 368
 369   rc= memcached_mget(memc, keys, key_length, 3);
 370   assert(rc == MEMCACHED_SUCCESS);
 371
 372   x= 0;
 373   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 374                                         &return_value_length, &flags, &rc)))
 375   {
 376     assert(return_value);
 377     assert(rc == MEMCACHED_SUCCESS);
 378     assert(return_key_length == return_value_length);
 379     assert(!memcmp(return_value, return_key, return_value_length));
 380     free(return_value);
 381     x++;
 382   }
 383 }
 384
 385 void get_stats_keys(memcached_st *memc)
 386 {
 387  char **list;
 388  char **ptr;
 389  memcached_stat_st stat;
 390  memcached_return rc;
 391
 392  list= memcached_stat_get_keys(memc, &stat, &rc);
 393  assert(rc == MEMCACHED_SUCCESS);
 394  for (ptr= list; *ptr; ptr++)
 395    printf("Found key %s\n", *ptr);
 396  fflush(stdout);
 397
 398  free(list);
 399 }
 400
 401 void get_stats(memcached_st *memc)
 402 {
 403  unsigned int x;
 404  char **list;
 405  char **ptr;
 406  memcached_return rc;
 407  memcached_stat_st *stat;
 408
 409  stat= memcached_stat(memc, NULL, &rc);
 410  assert(rc == MEMCACHED_SUCCESS);
 411
 412  assert(rc == MEMCACHED_SUCCESS);
 413  assert(stat);
 414
 415  for (x= 0; x < memcached_server_count(memc); x++)
 416  {
 417    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 418    assert(rc == MEMCACHED_SUCCESS);
 419    for (ptr= list; *ptr; ptr++)
 420      printf("Found key %s\n", *ptr);
 421
 422    free(list);
 423  }
 424
 425  free(stat);
 426 }
 427
 428 void add_host_test(memcached_st *memc)
 429 {
 430   unsigned int x;
 431   memcached_server_st *servers;
 432   memcached_return rc;
 433   char servername[]= "0.example.com";
 434
 435   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 436   assert(servers);
 437   assert(1 == memcached_server_list_count(servers));
 438
 439   for (x= 2; x < 20; x++)
 440   {
 441     char buffer[SMALL_STRING_LEN];
 442
 443     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 444     servers= memcached_server_list_append(servers, buffer, 401,
 445                                      &rc);
 446     assert(rc == MEMCACHED_SUCCESS);
 447     assert(x == memcached_server_list_count(servers));
 448   }
 449
 450   rc= memcached_server_push(memc, servers);
 451   assert(rc == MEMCACHED_SUCCESS);
 452   rc= memcached_server_push(memc, servers);
 453   assert(rc == MEMCACHED_SUCCESS);
 454
 455   memcached_server_list_free(servers);
 456 }
 457
 458 /* We don't test the behavior itself, we test the switches */
 459 void behavior_test(memcached_st *memc)
 460 {
 461   unsigned long long value;
 462   unsigned int set= 1;
 463
 464   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 465   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 466   assert(value == 1);
 467
 468   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 469   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 470   assert(value == 1);
 471
 472   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
 473   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
 474   assert(value == 1);
 475
 476   set= 0;
 477
 478   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 479   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 480   assert(value == 0);
 481
 482   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 483   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 484   assert(value == 0);
 485
 486   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
 487   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
 488   assert(value == 0);
 489 }
 490
 491 /* Test case provided by Cal Haldenbrand */
 492 void user_supplied_bug1(memcached_st *memc)
 493 {
 494   unsigned int setter= 1;
 495   unsigned int x;
 496
 497   long total= 0;
 498   int size= 0;
 499   srand(time(NULL));
 500   char key[10];
 501   char *randomstuff = (char *)malloc(6 * 1024);
 502   memset(randomstuff, 0, 6 * 1024);
 503
 504   memcached_return rc;
 505
 506   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 507   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 508
 509
 510   /* add key */
 511   for (x= 0 ; total < 20 * 1024576 ; x++ )
 512   {
 513     unsigned int j= 0;
 514
 515     size= (rand() % ( 5 * 1024 ) ) + 400;
 516     memset(randomstuff, 0, 6 * 1024);
 517     assert(size < 6 * 1024); /* Being safe here */
 518
 519     for (j= 0 ; j < size ;j++)
 520       randomstuff[j] = (char) (rand() % 26) + 97;
 521
 522     total += size;
 523     sprintf(key, "%d", x);
 524     rc = memcached_set(memc, key, strlen(key),
 525                        randomstuff, strlen(randomstuff), 10, 0);
 526     /* If we fail, lets try again */
 527     if (rc != MEMCACHED_SUCCESS)
 528       rc = memcached_set(memc, key, strlen(key),
 529                          randomstuff, strlen(randomstuff), 10, 0);
 530     assert(rc == MEMCACHED_SUCCESS);
 531   }
 532 }
 533 void add_host_test1(memcached_st *memc)
 534 {
 535   unsigned int x;
 536   memcached_return rc;
 537   char servername[]= "0.example.com";
 538   memcached_server_st *servers;
 539
 540   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 541   assert(servers);
 542   assert(1 == memcached_server_list_count(servers));
 543
 544   for (x= 2; x < 20; x++)
 545   {
 546     char buffer[SMALL_STRING_LEN];
 547
 548     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 549     servers= memcached_server_list_append(servers, buffer, 401,
 550                                      &rc);
 551     assert(rc == MEMCACHED_SUCCESS);
 552     assert(x == memcached_server_list_count(servers));
 553   }
 554
 555   rc= memcached_server_push(memc, servers);
 556   assert(rc == MEMCACHED_SUCCESS);
 557   rc= memcached_server_push(memc, servers);
 558   assert(rc == MEMCACHED_SUCCESS);
 559
 560   memcached_server_list_free(servers);
 561 }
 562
 563 typedef struct test_st test_st;
 564
 565 struct test_st {
 566   char *function_name;
 567   unsigned int requires_flush;
 568   void (*function)(memcached_st *memc);
 569 };
 570
 571 int main(int argc, char *argv[])
 572 {
 573   unsigned int x;
 574   char *server_list;
 575   char *test_to_run= NULL;
 576   char *wildcard= NULL;
 577   memcached_server_st *servers;
 578
 579   if (argc > 2)
 580     test_to_run= argv[1];
 581
 582   if (argc == 3)
 583     wildcard= argv[2];
 584
 585   if (!(server_list= getenv("MEMCACHED_SERVERS")))
 586     server_list= "localhost";
 587
 588   printf("servers %s\n", server_list);
 589   srandom(time(NULL));
 590
 591   servers= memcached_servers_parse(server_list);
 592   assert(servers);
 593
 594   for (x= 0; x < memcached_server_list_count(servers); x++)
 595   {
 596     printf("\t%s : %u\n", servers[x].hostname, servers[x].port);
 597     assert(servers[x].stack_responses == 0);
 598     assert(servers[x].fd == -1);
 599     assert(servers[x].cursor_active == 0);
 600   }
 601
 602   printf("\n");
 603
 604   /* Clean the server before beginning testing */
 605   test_st tests[] ={
 606     {"flush", 0, flush_test },
 607     {"init", 0, init_test },
 608     {"allocation", 0, allocation_test },
 609     {"error", 0, error_test },
 610     {"set", 0, set_test },
 611     {"set2", 0, set_test2 },
 612     {"set3", 0, set_test3 },
 613     {"add", 0, add_test },
 614     {"replace", 0, replace_test },
 615     {"delete", 1, delete_test },
 616     {"get", 0, get_test },
 617     {"get2", 0, get_test2 },
 618     {"get3", 0, get_test3 },
 619     {"get4", 0, get_test4 },
 620     {"stats_servername", 0, stats_servername_test },
 621     {"increment", 0, increment_test },
 622     {"decrement", 0, decrement_test },
 623     {"quit", 0, quit_test },
 624     {"mget", 0, mget_test },
 625     {"get_stats", 0, get_stats },
 626     {"add_host_test", 0, add_host_test },
 627     {"get_stats_keys", 0, get_stats_keys },
 628     {"behavior_test", 0, get_stats_keys },
 629     {0, 0, 0}
 630   };
 631
 632   test_st user_tests[] ={
 633     {"user_supplied_bug1", 0, user_supplied_bug1 },
 634     {0, 0, 0}
 635   };
 636
 637   if ((test_to_run && !strcmp(test_to_run, "block")) || !test_to_run)
 638   {
 639     fprintf(stderr, "\nBlock tests\n\n");
 640     for (x= 0; tests[x].function_name; x++)
 641     {
 642       if (wildcard)
 643         if (strcmp(wildcard, tests[x].function_name))
 644           continue;
 645
 646       memcached_st *memc;
 647       memcached_return rc;
 648       memc= memcached_create(NULL);
 649       assert(memc);
 650
 651       rc= memcached_server_push(memc, servers);
 652       assert(rc == MEMCACHED_SUCCESS);
 653
 654       unsigned int loop;
 655       for (loop= 0; loop < memcached_server_list_count(servers); loop++)
 656       {
 657         assert(memc->hosts[loop].stack_responses == 0);
 658         assert(memc->hosts[loop].fd == -1);
 659         assert(memc->hosts[loop].cursor_active == 0);
 660       }
 661
 662       fprintf(stderr, "Testing %s", tests[x].function_name);
 663       tests[x].function(memc);
 664       fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 665       assert(memc);
 666       memcached_free(memc);
 667     }
 668   }
 669
 670   if ((test_to_run && !strcmp(test_to_run, "nonblock")) || !test_to_run)
 671   {
 672     fprintf(stderr, "\nNonblock tests\n\n");
 673     for (x= 0; tests[x].function_name; x++)
 674     {
 675       if (wildcard)
 676         if (strcmp(wildcard, tests[x].function_name))
 677           continue;
 678
 679       memcached_st *memc;
 680       memcached_return rc;
 681       memc= memcached_create(NULL);
 682       assert(memc);
 683
 684       rc= memcached_server_push(memc, servers);
 685       assert(rc == MEMCACHED_SUCCESS);
 686
 687       fprintf(stderr, "Testing %s", tests[x].function_name);
 688       memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 689       tests[x].function(memc);
 690       fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 691       assert(memc);
 692       memcached_free(memc);
 693     }
 694   }
 695
 696   if ((test_to_run && !strcmp(test_to_run, "nodelay")) || !test_to_run)
 697   {
 698     fprintf(stderr, "\nTCP Nodelay tests\n\n");
 699     for (x= 0; tests[x].function_name; x++)
 700     {
 701       if (wildcard)
 702         if (strcmp(wildcard, tests[x].function_name))
 703           continue;
 704
 705       memcached_st *memc;
 706       memcached_return rc;
 707       memc= memcached_create(NULL);
 708       assert(memc);
 709
 710       rc= memcached_server_push(memc, servers);
 711       assert(rc == MEMCACHED_SUCCESS);
 712
 713       fprintf(stderr, "Testing %s", tests[x].function_name);
 714       memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 715       memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
 716       tests[x].function(memc);
 717       fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 718       assert(memc);
 719       memcached_free(memc);
 720     }
 721   }
 722
 723   if ((test_to_run && !strcmp(test_to_run, "md5")) || !test_to_run)
 724   {
 725     fprintf(stderr, "\nMD5 Hashing\n\n");
 726     for (x= 0; tests[x].function_name; x++)
 727     {
 728       if (wildcard)
 729         if (strcmp(wildcard, tests[x].function_name))
 730           continue;
 731
 732       memcached_st *memc;
 733       memcached_return rc;
 734       memc= memcached_create(NULL);
 735       assert(memc);
 736
 737       rc= memcached_server_push(memc, servers);
 738       assert(rc == MEMCACHED_SUCCESS);
 739
 740       fprintf(stderr, "Testing %s", tests[x].function_name);
 741       memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL);
 742       tests[x].function(memc);
 743       fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 744       assert(memc);
 745       memcached_free(memc);
 746     }
 747   }
 748
 749   if ((test_to_run && !strcmp(test_to_run, "user")) || !test_to_run)
 750   {
 751     fprintf(stderr, "\nUser Supplied tests\n\n");
 752     for (x= 0; user_tests[x].function_name; x++)
 753     {
 754       if (wildcard)
 755         if (strcmp(wildcard, tests[x].function_name))
 756           continue;
 757
 758       memcached_st *memc;
 759       memcached_return rc;
 760       memc= memcached_create(NULL);
 761       assert(memc);
 762
 763       rc= memcached_server_push(memc, servers);
 764       assert(rc == MEMCACHED_SUCCESS);
 765
 766       fprintf(stderr, "Testing %s", user_tests[x].function_name);
 767       user_tests[x].function(memc);
 768       fprintf(stderr, "\t\t\t\t\t[ ok ]\n");
 769       assert(memc);
 770       memcached_free(memc);
 771     }
 772   }
 773
 774   /* Clean up whatever we might have left */
 775   {
 776     memcached_st *memc;
 777     memc= memcached_create(NULL);
 778     assert(memc);
 779     flush_test(memc);
 780     memcached_free(memc);
 781   }
 782
 783   fprintf(stderr, "All tests completed successfully\n\n");
 784
 785   return 0;
 786 }