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
 613   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
 614 #endif
 615
 616   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
 617   {
 618     memcached_return rc= MEMCACHED_SUCCESS;
 619     char buffer[SMALL_STRING_LEN];
 620     uint16_t flags= 0;
 621     size_t val_len= 0;
 622     char *getval;
 623
 624     memset(buffer, 0, SMALL_STRING_LEN);
 625
 626     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
 627     getval= memcached_get(memc, buffer, strlen(buffer),
 628                            &val_len, &flags, &rc);
 629     if (rc != MEMCACHED_SUCCESS)
 630     {
 631       if (rc == MEMCACHED_NOTFOUND)
 632         errors++;
 633       else
 634         assert(0);
 635
 636       continue;
 637     }
 638     total+= val_len;
 639     errors= 0;
 640     free(getval);
 641   }
 642 }
 643
 644 /* Do a large mget() over all the keys we think exist */
 645 #define KEY_COUNT 3000 // * 1024576
 646 void user_supplied_bug3(memcached_st *memc)
 647 {
 648   memcached_return rc;
 649   unsigned int setter;
 650   unsigned int x;
 651   char **keys;
 652   size_t key_lengths[KEY_COUNT];
 653
 654   setter= 1;
 655   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
 656   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
 657 #ifdef NOT_YET
 658   setter = 20 * 1024576;
 659   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
 660   setter = 20 * 1024576;
 661   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
 662   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
 663   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
 664 #endif
 665
 666   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
 667   assert(keys);
 668   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
 669   for (x= 0; x < KEY_COUNT; x++)
 670   {
 671     char buffer[30];
 672
 673     snprintf(buffer, 30, "%u", x);
 674     keys[x]= strdup(buffer);
 675     key_lengths[x]= strlen(keys[x]);
 676   }
 677
 678   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
 679   assert(rc == MEMCACHED_SUCCESS);
 680
 681   /* Turn this into a help function */
 682   {
 683     char return_key[MEMCACHED_MAX_KEY];
 684     size_t return_key_length;
 685     char *return_value;
 686     size_t return_value_length;
 687     uint16_t flags;
 688
 689     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 690                                           &return_value_length, &flags, &rc)))
 691     {
 692       assert(return_value);
 693       assert(rc == MEMCACHED_SUCCESS);
 694       free(return_value);
 695     }
 696   }
 697
 698   for (x= 0; x < KEY_COUNT; x++)
 699     free(keys[x]);
 700   free(keys);
 701 }
 702
 703 void string_alloc_null(memcached_st *memc)
 704 {
 705   memcached_string_st *string;
 706
 707   string= memcached_string_create(memc, 0);
 708   assert(string);
 709   memcached_string_free(memc, string);
 710 }
 711
 712 void string_alloc_with_size(memcached_st *memc)
 713 {
 714   memcached_string_st *string;
 715
 716   string= memcached_string_create(memc, 1024);
 717   assert(string);
 718   memcached_string_free(memc, string);
 719 }
 720
 721 void string_alloc_with_size_toobig(memcached_st *memc)
 722 {
 723   memcached_string_st *string;
 724
 725   string= memcached_string_create(memc, INT64_MAX);
 726   assert(string == NULL);
 727 }
 728
 729 void string_alloc_append(memcached_st *memc)
 730 {
 731   unsigned int x;
 732   char buffer[SMALL_STRING_LEN];
 733   memcached_string_st *string;
 734
 735   /* Ring the bell! */
 736   memset(buffer, 6, SMALL_STRING_LEN);
 737
 738   string= memcached_string_create(memc, 100);
 739   assert(string);
 740
 741   for (x= 0; x < 1024; x++)
 742   {
 743     memcached_return rc;
 744     rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN);
 745     assert(rc == MEMCACHED_SUCCESS);
 746   }
 747   memcached_string_free(memc, string);
 748 }
 749
 750 void string_alloc_append_toobig(memcached_st *memc)
 751 {
 752   memcached_return rc;
 753   unsigned int x;
 754   char buffer[SMALL_STRING_LEN];
 755   memcached_string_st *string;
 756
 757   /* Ring the bell! */
 758   memset(buffer, 6, SMALL_STRING_LEN);
 759
 760   string= memcached_string_create(memc, 100);
 761   assert(string);
 762
 763   for (x= 0; x < 1024; x++)
 764   {
 765     rc= memcached_string_append(memc, string, buffer, SMALL_STRING_LEN);
 766     assert(rc == MEMCACHED_SUCCESS);
 767   }
 768   rc= memcached_string_append(memc, string, buffer, INT64_MAX);
 769   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
 770   memcached_string_free(memc, string);
 771 }
 772
 773 void add_host_test1(memcached_st *memc)
 774 {
 775   unsigned int x;
 776   memcached_return rc;
 777   char servername[]= "0.example.com";
 778   memcached_server_st *servers;
 779
 780   servers= memcached_server_list_append(NULL, servername, 400, &rc);
 781   assert(servers);
 782   assert(1 == memcached_server_list_count(servers));
 783
 784   for (x= 2; x < 20; x++)
 785   {
 786     char buffer[SMALL_STRING_LEN];
 787
 788     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
 789     servers= memcached_server_list_append(servers, buffer, 401,
 790                                      &rc);
 791     assert(rc == MEMCACHED_SUCCESS);
 792     assert(x == memcached_server_list_count(servers));
 793   }
 794
 795   rc= memcached_server_push(memc, servers);
 796   assert(rc == MEMCACHED_SUCCESS);
 797   rc= memcached_server_push(memc, servers);
 798   assert(rc == MEMCACHED_SUCCESS);
 799
 800   memcached_server_list_free(servers);
 801 }
 802
 803 void pre_nonblock(memcached_st *memc)
 804 {
 805   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 806 }
 807
 808 void pre_md5(memcached_st *memc)
 809 {
 810   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_MD5_HASHING, NULL);
 811 }
 812
 813 void pre_crc(memcached_st *memc)
 814 {
 815   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CRC_HASHING, NULL);
 816 }
 817
 818 void pre_nodelay(memcached_st *memc)
 819 {
 820   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
 821   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
 822 }
 823
 824 typedef struct collection_st collection_st;
 825 typedef struct test_st test_st;
 826
 827 struct test_st {
 828   char *name;
 829   unsigned int requires_flush;
 830   void (*function)(memcached_st *memc);
 831 };
 832
 833 struct collection_st {
 834   char *name;
 835   void (*pre)(memcached_st *memc);
 836   void (*post)(memcached_st *memc);
 837   test_st *tests;
 838 };
 839
 840 int main(int argc, char *argv[])
 841 {
 842   unsigned int x;
 843   char *server_list;
 844   char *collection_to_run= NULL;
 845   char *wildcard= NULL;
 846   memcached_server_st *servers;
 847
 848
 849   if (argc > 1)
 850     collection_to_run= argv[1];
 851
 852   if (argc == 3)
 853     wildcard= argv[2];
 854
 855   if (!(server_list= getenv("MEMCACHED_SERVERS")))
 856     server_list= "localhost";
 857
 858   printf("servers %s\n", server_list);
 859   srandom(time(NULL));
 860
 861   servers= memcached_servers_parse(server_list);
 862   assert(servers);
 863
 864   for (x= 0; x < memcached_server_list_count(servers); x++)
 865   {
 866     printf("\t%s : %u\n", servers[x].hostname, servers[x].port);
 867     assert(servers[x].stack_responses == 0);
 868     assert(servers[x].fd == -1);
 869     assert(servers[x].cursor_active == 0);
 870   }
 871
 872   printf("\n");
 873
 874   /* Clean the server before beginning testing */
 875   test_st tests[] ={
 876     {"flush", 0, flush_test },
 877     {"init", 0, init_test },
 878     {"allocation", 0, allocation_test },
 879     {"clone_test", 0, clone_test },
 880     {"error", 0, error_test },
 881     {"set", 0, set_test },
 882     {"set2", 0, set_test2 },
 883     {"set3", 0, set_test3 },
 884     {"add", 0, add_test },
 885     {"replace", 0, replace_test },
 886     {"delete", 1, delete_test },
 887     {"get", 1, get_test },
 888     {"get2", 0, get_test2 },
 889     {"get3", 0, get_test3 },
 890     {"get4", 0, get_test4 },
 891     {"stats_servername", 0, stats_servername_test },
 892     {"increment", 0, increment_test },
 893     {"decrement", 0, decrement_test },
 894     {"quit", 0, quit_test },
 895     {"mget", 0, mget_test },
 896     {"get_stats", 0, get_stats },
 897     {"add_host_test", 0, add_host_test },
 898     {"get_stats_keys", 0, get_stats_keys },
 899     {"behavior_test", 0, get_stats_keys },
 900     {0, 0, 0}
 901   };
 902
 903   test_st string_tests[] ={
 904     {"string alloc with null", 0, string_alloc_null },
 905     {"string alloc with 1K", 0, string_alloc_with_size },
 906     {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
 907     {"string append", 0, string_alloc_append },
 908     {"string append failure (too big)", 0, string_alloc_append_toobig },
 909     {0, 0, 0}
 910   };
 911
 912   test_st user_tests[] ={
 913     {"user_supplied_bug1", 0, user_supplied_bug1 },
 914     {"user_supplied_bug2", 0, user_supplied_bug2 },
 915     {"user_supplied_bug3", 0, user_supplied_bug3 },
 916     {0, 0, 0}
 917   };
 918
 919
 920   collection_st collection[] ={
 921     {"block", 0, 0, tests},
 922     {"nonblock", pre_nonblock, 0, tests},
 923     {"nodelay", pre_nodelay, 0, tests},
 924     {"md5", pre_md5, 0, tests},
 925     {"crc", pre_crc, 0, tests},
 926     {"string", 0, 0, string_tests},
 927     {"user", 0, 0, user_tests},
 928     {0, 0, 0, 0}
 929   };
 930
 931   collection_st *next;
 932   for (next= collection; next->name; next++)
 933   {
 934     test_st *run;
 935
 936     run= next->tests;
 937
 938     if (collection_to_run && strcmp(collection_to_run, next->name))
 939       continue;
 940
 941     fprintf(stderr, "\n%s\n\n", next->name);
 942
 943     for (x= 0; run->name; run++)
 944     {
 945       if (wildcard && strcmp(wildcard, run->name))
 946         continue;
 947
 948       fprintf(stderr, "Testing %s", run->name);
 949
 950       memcached_st *memc;
 951       memcached_return rc;
 952       struct timeval start_time, end_time;
 953
 954       memc= memcached_create(NULL);
 955       assert(memc);
 956
 957       if (run->requires_flush)
 958         memcached_flush(memc, 0);
 959
 960       rc= memcached_server_push(memc, servers);
 961       assert(rc == MEMCACHED_SUCCESS);
 962
 963       unsigned int loop;
 964       for (loop= 0; loop < memcached_server_list_count(servers); loop++)
 965       {
 966         assert(memc->hosts[loop].stack_responses == 0);
 967         assert(memc->hosts[loop].fd == -1);
 968         assert(memc->hosts[loop].cursor_active == 0);
 969       }
 970
 971       if (next->pre)
 972         next->pre(memc);
 973
 974       gettimeofday(&start_time, NULL);
 975       run->function(memc);
 976       gettimeofday(&end_time, NULL);
 977       long int load_time= timedif(end_time, start_time);
 978       fprintf(stderr, "\t\t\t\t\t %ld.%03ld [ ok ]\n", load_time / 1000,
 979               load_time % 1000);
 980
 981       if (next->post)
 982         next->post(memc);
 983
 984       assert(memc);
 985       memcached_free(memc);
 986     }
 987   }
 988
 989   /* Clean up whatever we might have left */
 990   {
 991     memcached_st *memc;
 992     memc= memcached_create(NULL);
 993     assert(memc);
 994     flush_test(memc);
 995     memcached_free(memc);
 996   }
 997
 998   fprintf(stderr, "All tests completed successfully\n\n");
 999
1000   memcached_server_list_free(servers);
1001
1002   return 0;
1003 }