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 #include <sys/time.h>
  10 #include <time.h>
  11 #include "../lib/common.h"
  12
  13 long int timedif(struct timeval a, struct timeval b)
  14 {
  15   register int us, s;
  16
  17   us = a.tv_usec - b.tv_usec;
  18   us /= 1000;
  19   s = a.tv_sec - b.tv_sec;
  20   s *= 1000;
  21   return s + us;
  22 }
  23
  24 void init_test(memcached_st *not_used)
  25 {
  26   memcached_st memc;
  27
  28   (void)memcached_create(&memc);
  29   memcached_free(&memc);
  30 }
  31
  32 void allocation_test(memcached_st *not_used)
  33 {
  34   memcached_st *memc;
  35   memc= memcached_create(NULL);
  36   assert(memc);
  37   memcached_free(memc);
  38 }
  39
  40 void clone_test(memcached_st *memc)
  41 {
  42   /* All null? */
  43   {
  44     memcached_st *clone;
  45     clone= memcached_clone(NULL, NULL);
  46     assert(clone);
  47     memcached_free(clone);
  48   }
  49
  50   /* Can we init from null? */
  51   {
  52     memcached_st *clone;
  53     clone= memcached_clone(NULL, memc);
  54     assert(clone);
  55     memcached_free(clone);
  56   }
  57
  58   /* Can we init from struct? */
  59   {
  60     memcached_st declared_clone;
  61     memcached_st *clone;
  62     clone= memcached_clone(&declared_clone, NULL);
  63     assert(clone);
  64     memcached_free(clone);
  65   }
  66
  67   /* Can we init from struct? */
  68   {
  69     memcached_st declared_clone;
  70     memcached_st *clone;
  71     clone= memcached_clone(&declared_clone, memc);
  72     assert(clone);
  73     memcached_free(clone);
  74   }
  75 }
  76
  77 void connection_test(memcached_st *memc)
  78 {
  79   memcached_return rc;
  80
  81   rc= memcached_server_add(memc, "localhost", 0);
  82   assert(rc == MEMCACHED_SUCCESS);
  83 }
  84
  85 void error_test(memcached_st *memc)
  86 {
  87   memcached_return rc;
  88
  89   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
  90   {
  91     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
  92   }
  93 }
  94
  95 void set_test(memcached_st *memc)
  96 {
  97   memcached_return rc;
  98   char *key= "foo";
  99   char *value= "when we sanitize";
 100
 101   rc= memcached_set(memc, key, strlen(key),
 102                     value, strlen(value),
 103                     (time_t)0, (uint16_t)0);
 104   assert(rc == MEMCACHED_SUCCESS);
 105 }
 106
 107 void add_test(memcached_st *memc)
 108 {
 109   memcached_return rc;
 110   char *key= "foo";
 111   char *value= "when we sanitize";
 112
 113   rc= memcached_add(memc, key, strlen(key),
 114                     value, strlen(value),
 115                     (time_t)0, (uint16_t)0);
 116   assert(rc == MEMCACHED_NOTSTORED);
 117 }
 118
 119 void replace_test(memcached_st *memc)
 120 {
 121   memcached_return rc;
 122   char *key= "foo";
 123   char *value= "when we sanitize";
 124
 125   rc= memcached_replace(memc, key, strlen(key),
 126                     value, strlen(value),
 127                     (time_t)0, (uint16_t)0);
 128   assert(rc == MEMCACHED_SUCCESS);
 129 }
 130
 131 void delete_test(memcached_st *memc)
 132 {
 133   memcached_return rc;
 134   char *key= "foo";
 135   char *value= "when we sanitize";
 136
 137   rc= memcached_set(memc, key, strlen(key),
 138                     value, strlen(value),
 139                     (time_t)0, (uint16_t)0);
 140   assert(rc == MEMCACHED_SUCCESS);
 141
 142   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 143   assert(rc == MEMCACHED_SUCCESS);
 144 }
 145
 146 void flush_test(memcached_st *memc)
 147 {
 148   memcached_return rc;
 149
 150   rc= memcached_flush(memc, 0);
 151   assert(rc == MEMCACHED_SUCCESS);
 152 }
 153
 154 void get_test(memcached_st *memc)
 155 {
 156   memcached_return rc;
 157   char *key= "foo";
 158   char *string;
 159   size_t string_length;
 160   uint16_t flags;
 161
 162   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 163   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOTFOUND);
 164
 165   string= memcached_get(memc, key, strlen(key),
 166                         &string_length, &flags, &rc);
 167
 168   assert(rc == MEMCACHED_NOTFOUND);
 169   assert(string_length ==  0);
 170   assert(!string);
 171 }
 172
 173 void get_test2(memcached_st *memc)
 174 {
 175   memcached_return rc;
 176   char *key= "foo";
 177   char *value= "when we sanitize";
 178   char *string;
 179   size_t string_length;
 180   uint16_t flags;
 181
 182   rc= memcached_set(memc, key, strlen(key),
 183                     value, strlen(value),
 184                     (time_t)0, (uint16_t)0);
 185   assert(rc == MEMCACHED_SUCCESS);
 186
 187   string= memcached_get(memc, key, strlen(key),
 188                         &string_length, &flags, &rc);
 189
 190   assert(string);
 191   assert(rc == MEMCACHED_SUCCESS);
 192   assert(string_length == strlen(value));
 193   assert(!memcmp(string, value, string_length));
 194
 195   free(string);
 196 }
 197
 198 void set_test2(memcached_st *memc)
 199 {
 200   memcached_return rc;
 201   char *key= "foo";
 202   char *value= "train in the brain";
 203   size_t value_length= strlen(value);
 204   unsigned int x;
 205
 206   for (x= 0; x < 10; x++)
 207   {
 208     rc= memcached_set(memc, key, strlen(key),
 209                       value, value_length,
 210                       (time_t)0, (uint16_t)0);
 211     assert(rc == MEMCACHED_SUCCESS);
 212   }
 213 }
 214
 215 void set_test3(memcached_st *memc)
 216 {
 217   memcached_return rc;
 218   char *key= "foo";
 219   char *value;
 220   size_t value_length= 8191;
 221   unsigned int x;
 222
 223   value = (char*)malloc(value_length);
 224   assert(value);
 225
 226   for (x= 0; x < value_length; x++)
 227     value[x] = (char) (x % 127);
 228
 229   for (x= 0; x < 1; x++)
 230   {
 231     rc= memcached_set(memc, key, strlen(key),
 232                       value, value_length,
 233                       (time_t)0, (uint16_t)0);
 234     assert(rc == MEMCACHED_SUCCESS);
 235   }
 236
 237   free(value);
 238 }
 239
 240 void get_test3(memcached_st *memc)
 241 {
 242   memcached_return rc;
 243   char *key= "foo";
 244   char *value;
 245   size_t value_length= 8191;
 246   char *string;
 247   size_t string_length;
 248   uint16_t flags;
 249   int x;
 250
 251   value = (char*)malloc(value_length);
 252   assert(value);
 253
 254   for (x= 0; x < value_length; x++)
 255     value[x] = (char) (x % 127);
 256
 257   rc= memcached_set(memc, key, strlen(key),
 258                     value, value_length,
 259                     (time_t)0, (uint16_t)0);
 260   assert(rc == MEMCACHED_SUCCESS);
 261
 262   string= memcached_get(memc, key, strlen(key),
 263                         &string_length, &flags, &rc);
 264
 265   assert(rc == MEMCACHED_SUCCESS);
 266   assert(string);
 267   assert(string_length == value_length);
 268   assert(!memcmp(string, value, string_length));
 269
 270   free(string);
 271   free(value);
 272 }
 273
 274 void get_test4(memcached_st *memc)
 275 {
 276   memcached_return rc;
 277   char *key= "foo";
 278   char *value;
 279   size_t value_length= 8191;
 280   char *string;
 281   size_t string_length;
 282   uint16_t flags;
 283   int x;
 284
 285   value = (char*)malloc(value_length);
 286   assert(value);
 287
 288   for (x= 0; x < value_length; x++)
 289     value[x] = (char) (x % 127);
 290
 291   rc= memcached_set(memc, key, strlen(key),
 292                     value, value_length,
 293                     (time_t)0, (uint16_t)0);
 294   assert(rc == MEMCACHED_SUCCESS);
 295
 296   for (x= 0; x < 10; x++)
 297   {
 298     string= memcached_get(memc, key, strlen(key),
 299                           &string_length, &flags, &rc);
 300
 301     assert(rc == MEMCACHED_SUCCESS);
 302     assert(string);
 303     assert(string_length == value_length);
 304     assert(!memcmp(string, value, string_length));
 305     free(string);
 306   }
 307
 308   free(value);
 309 }
 310
 311 void stats_servername_test(memcached_st *memc)
 312 {
 313   memcached_return rc;
 314   memcached_stat_st stat;
 315   rc= memcached_stat_servername(&stat, NULL,
 316                                  "localhost",
 317                                  MEMCACHED_DEFAULT_PORT);
 318 }
 319
 320 void increment_test(memcached_st *memc)
 321 {
 322   unsigned int new_number;
 323   memcached_return rc;
 324   char *key= "number";
 325   char *value= "0";
 326
 327   rc= memcached_set(memc, key, strlen(key),
 328                     value, strlen(value),
 329                     (time_t)0, (uint16_t)0);
 330   assert(rc == MEMCACHED_SUCCESS);
 331
 332   rc= memcached_increment(memc, key, strlen(key),
 333                           1, &new_number);
 334   assert(rc == MEMCACHED_SUCCESS);
 335   assert(new_number == 1);
 336
 337   rc= memcached_increment(memc, key, strlen(key),
 338                           1, &new_number);
 339   assert(rc == MEMCACHED_SUCCESS);
 340   assert(new_number == 2);
 341 }
 342
 343 void decrement_test(memcached_st *memc)
 344 {
 345   unsigned int new_number;
 346   memcached_return rc;
 347   char *key= "number";
 348   char *value= "3";
 349
 350   rc= memcached_set(memc, key, strlen(key),
 351                     value, strlen(value),
 352                     (time_t)0, (uint16_t)0);
 353   assert(rc == MEMCACHED_SUCCESS);
 354
 355   rc= memcached_decrement(memc, key, strlen(key),
 356                           1, &new_number);
 357   assert(rc == MEMCACHED_SUCCESS);
 358   assert(new_number == 2);
 359
 360   rc= memcached_decrement(memc, key, strlen(key),
 361                           1, &new_number);
 362   assert(rc == MEMCACHED_SUCCESS);
 363   assert(new_number == 1);
 364 }
 365
 366 void quit_test(memcached_st *memc)
 367 {
 368   memcached_return rc;
 369   char *key= "fudge";
 370   char *value= "sanford and sun";
 371
 372   rc= memcached_set(memc, key, strlen(key),
 373                     value, strlen(value),
 374                     (time_t)10, (uint16_t)3);
 375   assert(rc == MEMCACHED_SUCCESS);
 376   memcached_quit(memc);
 377
 378   rc= memcached_set(memc, key, strlen(key),
 379                     value, strlen(value),
 380                     (time_t)50, (uint16_t)9);
 381   assert(rc == MEMCACHED_SUCCESS);
 382 }
 383
 384 void mget_test(memcached_st *memc)
 385 {
 386   memcached_return rc;
 387   char *keys[]= {"fudge", "son", "food"};
 388   size_t key_length[]= {5, 3, 4};
 389   unsigned int x;
 390   uint16_t flags;
 391
 392   char return_key[MEMCACHED_MAX_KEY];
 393   size_t return_key_length;
 394   char *return_value;
 395   size_t return_value_length;
 396
 397   /* We need to empty the server before continueing test */
 398   rc= memcached_flush(memc, 0);
 399   assert(rc == MEMCACHED_SUCCESS);
 400
 401   rc= memcached_mget(memc, keys, key_length, 3);
 402   assert(rc == MEMCACHED_SUCCESS);
 403
 404   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 405                       &return_value_length, &flags, &rc)) != NULL)
 406   {
 407     assert(return_value);
 408   }
 409   assert(!return_value);
 410   assert(return_value_length == 0);
 411   assert(rc == MEMCACHED_NOTFOUND);
 412
 413   for (x= 0; x < 3; x++)
 414   {
 415     rc= memcached_set(memc, keys[x], key_length[x],
 416                       keys[x], key_length[x],
 417                       (time_t)50, (uint16_t)9);
 418     assert(rc == MEMCACHED_SUCCESS);
 419   }
 420
 421   rc= memcached_mget(memc, keys, key_length, 3);
 422   assert(rc == MEMCACHED_SUCCESS);
 423
 424   x= 0;
 425   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 426                                         &return_value_length, &flags, &rc)))
 427   {
 428     assert(return_value);
 429     assert(rc == MEMCACHED_SUCCESS);
 430     assert(return_key_length == return_value_length);
 431     assert(!memcmp(return_value, return_key, return_value_length));
 432     free(return_value);
 433     x++;
 434   }
 435 }
 436
 437 void get_stats_keys(memcached_st *memc)
 438 {
 439  char **list;
 440  char **ptr;
 441  memcached_stat_st stat;
 442  memcached_return rc;
 443
 444  list= memcached_stat_get_keys(memc, &stat, &rc);
 445  assert(rc == MEMCACHED_SUCCESS);
 446  for (ptr= list; *ptr; ptr++)
 447    printf("Found key %s\n", *ptr);
 448  fflush(stdout);
 449
 450  free(list);
 451 }
 452
 453 void get_stats(memcached_st *memc)
 454 {
 455  unsigned int x;
 456  char **list;
 457  char **ptr;
 458  memcached_return rc;
 459  memcached_stat_st *stat;
 460
 461  stat= memcached_stat(memc, NULL, &rc);
 462  assert(rc == MEMCACHED_SUCCESS);
 463
 464  assert(rc == MEMCACHED_SUCCESS);
 465  assert(stat);
 466
 467  for (x= 0; x < memcached_server_count(memc); x++)
 468  {
 469    list= memcached_stat_get_keys(memc, &stat[x], &rc);
 470    assert(rc == MEMCACHED_SUCCESS);
 471    for (ptr= list; *ptr; ptr++)
 472      printf("Found key %s\n", *ptr);
 473
 474    free(list);
 475  }
 476
 477  free(stat);
 478 }
 479
 480 void add_host_test(memcached_st *memc)
 481 {
 482   unsigned int x;
 483   memcached_server_st *servers;
 484   memcached_return rc;
 485   char servername[]= "0.example.com";
 486
 487   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 488   assert(servers);
 489   assert(1 == memcached_server_list_count(servers));
 490
 491   for (x= 2; x < 20; x++)
 492   {
 493     char buffer[SMALL_STRING_LEN];
 494
 495     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 496     servers= memcached_server_list_append(servers, buffer, 401,
 497                                      &rc);
 498     assert(rc == MEMCACHED_SUCCESS);
 499     assert(x == memcached_server_list_count(servers));
 500   }
 501
 502   rc= memcached_server_push(memc, servers);
 503   assert(rc == MEMCACHED_SUCCESS);
 504   rc= memcached_server_push(memc, servers);
 505   assert(rc == MEMCACHED_SUCCESS);
 506
 507   memcached_server_list_free(servers);
 508 }
 509
 510 /* We don't test the behavior itself, we test the switches */
 511 void behavior_test(memcached_st *memc)
 512 {
 513   unsigned long long value;
 514   unsigned int set= 1;
 515
 516   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 517   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 518   assert(value == 1);
 519
 520   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 521   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 522   assert(value == 1);
 523
 524   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
 525   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
 526   assert(value == 1);
 527
 528   set= 0;
 529
 530   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
 531   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 532   assert(value == 0);
 533
 534   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
 535   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
 536   assert(value == 0);
 537
 538   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, &set);
 539   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_MD5_HASHING);
 540   assert(value == 0);
 541
 542   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 543   assert(value > 0);
 544
 545   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 546   assert(value > 0);
 547 }
 548
 549 /* Test case provided by Cal Haldenbrand */
 550 void user_supplied_bug1(memcached_st *memc)
 551 {
 552   unsigned int setter= 1;
 553   unsigned int x;
 554
 555   unsigned long long total= 0;
 556   int size= 0;
 557   char key[10];
 558   char randomstuff[6 * 1024];
 559   memcached_return rc;
 560
 561   memset(randomstuff, 0, 6 * 1024);
 562
 563   /* We just keep looking at the same values over and over */
 564   srandom(10);
 565
 566   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 567   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 568
 569
 570   /* add key */
 571   for (x= 0 ; total < 20 * 1024576 ; x++ )
 572   {
 573     unsigned int j= 0;
 574
 575     size= (rand() % ( 5 * 1024 ) ) + 400;
 576     memset(randomstuff, 0, 6 * 1024);
 577     assert(size < 6 * 1024); /* Being safe here */
 578
 579     for (j= 0 ; j < size ;j++)
 580       randomstuff[j] = (char) (rand() % 26) + 97;
 581
 582     total += size;
 583     sprintf(key, "%d", x);
 584     rc = memcached_set(memc, key, strlen(key),
 585                        randomstuff, strlen(randomstuff), 10, 0);
 586     /* If we fail, lets try again */
 587     if (rc != MEMCACHED_SUCCESS)
 588       rc = memcached_set(memc, key, strlen(key),
 589                          randomstuff, strlen(randomstuff), 10, 0);
 590     assert(rc == MEMCACHED_SUCCESS);
 591   }
 592 }
 593
 594 /* Test case provided by Cal Haldenbrand */
 595 void user_supplied_bug2(memcached_st *memc)
 596 {
 597   int errors;
 598   unsigned int setter;
 599   unsigned int x;
 600   unsigned long long total;
 601
 602   setter= 1;
 603   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 604   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 605 #ifdef NOT_YET
 606   setter = 20 * 1024576;
 607   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 608   setter = 20 * 1024576;
 609   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 610   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 611   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 612 #endif
 613
 614   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
 615   {
 616     memcached_return rc= MEMCACHED_SUCCESS;
 617     char buffer[SMALL_STRING_LEN];
 618     uint16_t flags= 0;
 619     size_t val_len= 0;
 620     char *getval;
 621
 622     memset(buffer, 0, SMALL_STRING_LEN);
 623
 624     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
 625     getval= memcached_get(memc, buffer, strlen(buffer),
 626                            &val_len, &flags, &rc);
 627     if (rc != MEMCACHED_SUCCESS)
 628     {
 629       if (rc == MEMCACHED_NOTFOUND)
 630         errors++;
 631       else
 632         assert(0);
 633
 634       continue;
 635     }
 636     total+= val_len;
 637     errors= 0;
 638     free(getval);
 639   }
 640 }
 641
 642 /* Do a large mget() over all the keys we think exist */
 643 #define KEY_COUNT 3000 // * 1024576
 644 void user_supplied_bug3(memcached_st *memc)
 645 {
 646   memcached_return rc;
 647   unsigned int setter;
 648   unsigned int x;
 649   char **keys;
 650   size_t key_lengths[KEY_COUNT];
 651
 652   setter= 1;
 653   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 654   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 655 #ifdef NOT_YET
 656   setter = 20 * 1024576;
 657   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 658   setter = 20 * 1024576;
 659   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 660   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 661   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 662 #endif
 663
 664   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
 665   assert(keys);
 666   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
 667   for (x= 0; x < KEY_COUNT; x++)
 668   {
 669     char buffer[30];
 670
 671     snprintf(buffer, 30, "%u", x);
 672     keys[x]= strdup(buffer);
 673     key_lengths[x]= strlen(keys[x]);
 674   }
 675
 676   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
 677   assert(rc == MEMCACHED_SUCCESS);
 678
 679   /* Turn this into a help function */
 680   {
 681     char return_key[MEMCACHED_MAX_KEY];
 682     size_t return_key_length;
 683     char *return_value;
 684     size_t return_value_length;
 685     uint16_t flags;
 686
 687     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 688                                           &return_value_length, &flags, &rc)))
 689     {
 690       assert(return_value);
 691       assert(rc == MEMCACHED_SUCCESS);
 692       free(return_value);
 693     }
 694   }
 695
 696   for (x= 0; x < KEY_COUNT; x++)
 697     free(keys[x]);
 698   free(keys);
 699 }
 700
 701 void string_alloc_null(memcached_st *memc)
 702 {
 703   memcached_string_st *string;
 704
 705   string= memcached_string_create(memc, 0);
 706   assert(string);
 707   memcached_string_free(memc, string);
 708 }
 709
 710 void string_alloc_with_size(memcached_st *memc)
 711 {
 712   memcached_string_st *string;
 713
 714   string= memcached_string_create(memc, 1024);
 715   assert(string);
 716   memcached_string_free(memc, string);
 717 }
 718
 719 void string_alloc_with_size_toobig(memcached_st *memc)
 720 {
 721   memcached_string_st *string;
 722
 723   string= memcached_string_create(memc, INT64_MAX);
 724   assert(string == NULL);
 725 }
 726
 727 void string_alloc_append(memcached_st *memc)
 728 {
 729   unsigned int x;
 730   char buffer[SMALL_STRING_LEN];
 731   memcached_string_st *string;
 732
 733   /* Ring the bell! */
 734   memset(buffer, 6, SMALL_STRING_LEN);
 735
 736   string= memcached_string_create(memc, 100);
 737   assert(string);
 738
 739   for (x= 0; x < 1024; x++)
 740   {
 741     memcached_return rc;
 742     rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN);
 743     assert(rc == MEMCACHED_SUCCESS);
 744   }
 745   memcached_string_free(memc, string);
 746 }
 747
 748 void string_alloc_append_toobig(memcached_st *memc)
 749 {
 750   memcached_return rc;
 751   unsigned int x;
 752   char buffer[SMALL_STRING_LEN];
 753   memcached_string_st *string;
 754
 755   /* Ring the bell! */
 756   memset(buffer, 6, SMALL_STRING_LEN);
 757
 758   string= memcached_string_create(memc, 100);
 759   assert(string);
 760
 761   for (x= 0; x < 1024; x++)
 762   {
 763     rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN);
 764     assert(rc == MEMCACHED_SUCCESS);
 765   }
 766   rc= memcached_string_append(memc, string, buffer, INT64_MAX);
 767   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
 768   memcached_string_free(memc, string);
 769 }
 770
 771 void add_host_test1(memcached_st *memc)
 772 {
 773   unsigned int x;
 774   memcached_return rc;
 775   char servername[]= "0.example.com";
 776   memcached_server_st *servers;
 777
 778   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 779   assert(servers);
 780   assert(1 == memcached_server_list_count(servers));
 781
 782   for (x= 2; x < 20; x++)
 783   {
 784     char buffer[SMALL_STRING_LEN];
 785
 786     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 787     servers= memcached_server_list_append(servers, buffer, 401,
 788                                      &rc);
 789     assert(rc == MEMCACHED_SUCCESS);
 790     assert(x == memcached_server_list_count(servers));
 791   }
 792
 793   rc= memcached_server_push(memc, servers);
 794   assert(rc == MEMCACHED_SUCCESS);
 795   rc= memcached_server_push(memc, servers);
 796   assert(rc == MEMCACHED_SUCCESS);
 797
 798   memcached_server_list_free(servers);
 799 }
 800
 801 void pre_nonblock(memcached_st *memc)
 802 {
 803   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 804 }
 805
 806 void pre_md5(memcached_st *memc)
 807 {
 808   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL);
 809 }
 810
 811 void pre_nodelay(memcached_st *memc)
 812 {
 813   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 814   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
 815 }
 816
 817 typedef struct collection_st collection_st;
 818 typedef struct test_st test_st;
 819
 820 struct test_st {
 821   char *name;
 822   unsigned int requires_flush;
 823   void (*function)(memcached_st *memc);
 824 };
 825
 826 struct collection_st {
 827   char *name;
 828   void (*pre)(memcached_st *memc);
 829   void (*post)(memcached_st *memc);
 830   test_st *tests;
 831 };
 832
 833 int main(int argc, char *argv[])
 834 {
 835   unsigned int x;
 836   char *server_list;
 837   char *collection_to_run= NULL;
 838   char *wildcard= NULL;
 839   memcached_server_st *servers;
 840
 841
 842   if (argc > 1)
 843     collection_to_run= argv[1];
 844
 845   if (argc == 3)
 846     wildcard= argv[2];
 847
 848   if (!(server_list= getenv("MEMCACHED_SERVERS")))
 849     server_list= "localhost";
 850
 851   printf("servers %s\n", server_list);
 852   srandom(time(NULL));
 853
 854   servers= memcached_servers_parse(server_list);
 855   assert(servers);
 856
 857   for (x= 0; x < memcached_server_list_count(servers); x++)
 858   {
 859     printf("\t%s : %u\n", servers[x].hostname, servers[x].port);
 860     assert(servers[x].stack_responses == 0);
 861     assert(servers[x].fd == -1);
 862     assert(servers[x].cursor_active == 0);
 863   }
 864
 865   printf("\n");
 866
 867   /* Clean the server before beginning testing */
 868   test_st tests[] ={
 869     {"flush", 0, flush_test },
 870     {"init", 0, init_test },
 871     {"allocation", 0, allocation_test },
 872     {"clone_test", 0, clone_test },
 873     {"error", 0, error_test },
 874     {"set", 0, set_test },
 875     {"set2", 0, set_test2 },
 876     {"set3", 0, set_test3 },
 877     {"add", 0, add_test },
 878     {"replace", 0, replace_test },
 879     {"delete", 1, delete_test },
 880     {"get", 1, get_test },
 881     {"get2", 0, get_test2 },
 882     {"get3", 0, get_test3 },
 883     {"get4", 0, get_test4 },
 884     {"stats_servername", 0, stats_servername_test },
 885     {"increment", 0, increment_test },
 886     {"decrement", 0, decrement_test },
 887     {"quit", 0, quit_test },
 888     {"mget", 0, mget_test },
 889     {"get_stats", 0, get_stats },
 890     {"add_host_test", 0, add_host_test },
 891     {"get_stats_keys", 0, get_stats_keys },
 892     {"behavior_test", 0, get_stats_keys },
 893     {0, 0, 0}
 894   };
 895
 896   test_st string_tests[] ={
 897     {"string alloc with null", 0, string_alloc_null },
 898     {"string alloc with 1K", 0, string_alloc_with_size },
 899     {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
 900     {"string append", 0, string_alloc_append },
 901     {"string append failure (too big)", 0, string_alloc_append_toobig },
 902     {0, 0, 0}
 903   };
 904
 905   test_st user_tests[] ={
 906     {"user_supplied_bug1", 0, user_supplied_bug1 },
 907     {"user_supplied_bug2", 0, user_supplied_bug2 },
 908     {"user_supplied_bug3", 0, user_supplied_bug3 },
 909     {0, 0, 0}
 910   };
 911
 912
 913   collection_st collection[] ={
 914     {"block", 0, 0, tests},
 915     {"nonblock", pre_nonblock, 0, tests},
 916     {"nodelay", pre_nodelay, 0, tests},
 917     {"md5", pre_md5, 0, tests},
 918     {"string", 0, 0, string_tests},
 919     {"user", 0, 0, user_tests},
 920     {0, 0, 0, 0}
 921   };
 922
 923   collection_st *next;
 924   for (next= collection; next->name; next++)
 925   {
 926     test_st *run;
 927
 928     run= next->tests;
 929
 930     if (collection_to_run && strcmp(collection_to_run, next->name))
 931       continue;
 932
 933     fprintf(stderr, "\n%s\n\n", next->name);
 934
 935     for (x= 0; run->name; run++)
 936     {
 937       if (wildcard && strcmp(wildcard, run->name))
 938         continue;
 939
 940       fprintf(stderr, "Testing %s", run->name);
 941
 942       memcached_st *memc;
 943       memcached_return rc;
 944       struct timeval start_time, end_time;
 945
 946       memc= memcached_create(NULL);
 947       assert(memc);
 948
 949       if (run->requires_flush)
 950         memcached_flush(memc, 0);
 951
 952       rc= memcached_server_push(memc, servers);
 953       assert(rc == MEMCACHED_SUCCESS);
 954
 955       unsigned int loop;
 956       for (loop= 0; loop < memcached_server_list_count(servers); loop++)
 957       {
 958         assert(memc->hosts[loop].stack_responses == 0);
 959         assert(memc->hosts[loop].fd == -1);
 960         assert(memc->hosts[loop].cursor_active == 0);
 961       }
 962
 963       if (next->pre)
 964         next->pre(memc);
 965
 966       gettimeofday(&start_time, NULL);
 967       run->function(memc);
 968       gettimeofday(&end_time, NULL);
 969       long int load_time= timedif(end_time, start_time);
 970       fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
 971               load_time % 1000);
 972
 973       if (next->post)
 974         next->post(memc);
 975
 976       assert(memc);
 977       memcached_free(memc);
 978     }
 979   }
 980
 981   /* Clean up whatever we might have left */
 982   {
 983     memcached_st *memc;
 984     memc= memcached_create(NULL);
 985     assert(memc);
 986     flush_test(memc);
 987     memcached_free(memc);
 988   }
 989
 990   fprintf(stderr, "All tests completed successfully\n\n");
 991
 992   memcached_server_list_free(servers);
 993
 994   return 0;
 995 }