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