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