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