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 "server.h"
  15 #include "../lib/common.h"
  16 #include "../src/generator.h"
  17 #include "../src/execute.h"
  18
  19 #ifndef INT64_MAX
  20 #define INT64_MAX LONG_MAX
  21 #endif
  22 #ifndef INT32_MAX
  23 #define INT32_MAX INT_MAX
  24 #endif
  25
  26
  27 #include "test.h"
  28
  29 #define GLOBAL_COUNT 100000
  30 #define GLOBAL2_COUNT 1000
  31 static uint32_t global_count;
  32
  33 static pairs_st *global_pairs;
  34 static char *global_keys[GLOBAL_COUNT];
  35 static size_t global_keys_length[GLOBAL_COUNT];
  36
  37 uint8_t init_test(memcached_st *not_used)
  38 {
  39   memcached_st memc;
  40
  41   (void)memcached_create(&memc);
  42   memcached_free(&memc);
  43
  44   return 0;
  45 }
  46
  47 uint8_t server_list_null_test(memcached_st *ptr)
  48 {
  49   memcached_server_st *server_list;
  50   memcached_return rc;
  51
  52   server_list= memcached_server_list_append(NULL, NULL, 0, NULL);
  53   assert(server_list == NULL);
  54
  55   server_list= memcached_server_list_append(NULL, "localhost", 0, NULL);
  56   assert(server_list == NULL);
  57
  58   server_list= memcached_server_list_append(NULL, NULL, 0, &rc);
  59   assert(server_list == NULL);
  60
  61   return 0;
  62 }
  63
  64 uint8_t server_sort_test(memcached_st *ptr)
  65 {
  66   unsigned int setting;
  67   memcached_server_st *server_list;
  68   memcached_return rc;
  69
  70   setting= 1;
  71   memcached_behavior_set(ptr, MEMCACHED_BEHAVIOR_SORT_HOSTS, &setting);
  72
  73   server_list= memcached_server_list_append(NULL, "arg", 0, &rc);
  74   assert(server_list);
  75
  76   server_list= memcached_server_list_append(server_list, "localhost", 0, &rc);
  77   assert(server_list);
  78
  79   server_list= memcached_server_list_append(server_list, "c", 0, &rc);
  80   assert(server_list);
  81
  82   server_list= memcached_server_list_append(server_list, "abba", 0, &rc);
  83   assert(server_list);
  84
  85   free(server_list);
  86
  87   return 0;
  88 }
  89
  90 uint8_t allocation_test(memcached_st *not_used)
  91 {
  92   memcached_st *memc;
  93   memc= memcached_create(NULL);
  94   assert(memc);
  95   memcached_free(memc);
  96
  97   return 0;
  98 }
  99
 100 uint8_t clone_test(memcached_st *memc)
 101 {
 102   /* All null? */
 103   {
 104     memcached_st *clone;
 105     clone= memcached_clone(NULL, NULL);
 106     assert(clone);
 107     memcached_free(clone);
 108   }
 109
 110   /* Can we init from null? */
 111   {
 112     memcached_st *clone;
 113     clone= memcached_clone(NULL, memc);
 114     assert(clone);
 115     memcached_free(clone);
 116   }
 117
 118   /* Can we init from struct? */
 119   {
 120     memcached_st declared_clone;
 121     memcached_st *clone;
 122     clone= memcached_clone(&declared_clone, NULL);
 123     assert(clone);
 124     memcached_free(clone);
 125   }
 126
 127   /* Can we init from struct? */
 128   {
 129     memcached_st declared_clone;
 130     memcached_st *clone;
 131     clone= memcached_clone(&declared_clone, memc);
 132     assert(clone);
 133     memcached_free(clone);
 134   }
 135
 136   return 0;
 137 }
 138
 139 uint8_t connection_test(memcached_st *memc)
 140 {
 141   memcached_return rc;
 142
 143   rc= memcached_server_add(memc, "localhost", 0);
 144   assert(rc == MEMCACHED_SUCCESS);
 145
 146   return 0;
 147 }
 148
 149 uint8_t error_test(memcached_st *memc)
 150 {
 151   memcached_return rc;
 152
 153   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 154   {
 155     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 156   }
 157
 158   return 0;
 159 }
 160
 161 uint8_t set_test(memcached_st *memc)
 162 {
 163   memcached_return rc;
 164   char *key= "foo";
 165   char *value= "when we sanitize";
 166
 167   rc= memcached_set(memc, key, strlen(key),
 168                     value, strlen(value),
 169                     (time_t)0, (uint32_t)0);
 170   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 171
 172   return 0;
 173 }
 174
 175 uint8_t append_test(memcached_st *memc)
 176 {
 177   memcached_return rc;
 178   char *key= "fig";
 179   char *value= "we";
 180   size_t value_length;
 181   uint32_t flags;
 182
 183   rc= memcached_flush(memc, 0);
 184   assert(rc == MEMCACHED_SUCCESS);
 185
 186   rc= memcached_set(memc, key, strlen(key),
 187                     value, strlen(value),
 188                     (time_t)0, (uint32_t)0);
 189   assert(rc == MEMCACHED_SUCCESS);
 190
 191   rc= memcached_append(memc, key, strlen(key),
 192                        " the", strlen(" the"),
 193                        (time_t)0, (uint32_t)0);
 194   assert(rc == MEMCACHED_SUCCESS);
 195
 196   rc= memcached_append(memc, key, strlen(key),
 197                        " people", strlen(" people"),
 198                        (time_t)0, (uint32_t)0);
 199   assert(rc == MEMCACHED_SUCCESS);
 200
 201   value= memcached_get(memc, key, strlen(key),
 202                        &value_length, &flags, &rc);
 203   assert(!memcmp(value, "we the people", strlen("we the people")));
 204   assert(strlen("we the people") == value_length);
 205   assert(rc == MEMCACHED_SUCCESS);
 206   free(value);
 207
 208   return 0;
 209 }
 210
 211 uint8_t append_binary_test(memcached_st *memc)
 212 {
 213   memcached_return rc;
 214   char *key= "numbers";
 215   unsigned int *store_ptr;
 216   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 217   char *value;
 218   size_t value_length;
 219   uint32_t flags;
 220   unsigned int x;
 221
 222   rc= memcached_flush(memc, 0);
 223   assert(rc == MEMCACHED_SUCCESS);
 224
 225   rc= memcached_set(memc,
 226                     key, strlen(key),
 227                     NULL, 0,
 228                     (time_t)0, (uint32_t)0);
 229   assert(rc == MEMCACHED_SUCCESS);
 230
 231   for (x= 0; store_list[x] ; x++)
 232   {
 233     rc= memcached_append(memc,
 234                          key, strlen(key),
 235                          (char *)&store_list[x], sizeof(unsigned int),
 236                          (time_t)0, (uint32_t)0);
 237     assert(rc == MEMCACHED_SUCCESS);
 238   }
 239
 240   value= memcached_get(memc, key, strlen(key),
 241                        &value_length, &flags, &rc);
 242   assert((value_length == (sizeof(unsigned int) * x)));
 243   assert(rc == MEMCACHED_SUCCESS);
 244
 245   store_ptr= (unsigned int *)value;
 246   x= 0;
 247   while ((size_t)store_ptr < (size_t)(value + value_length))
 248   {
 249     assert(*store_ptr == store_list[x++]);
 250     store_ptr++;
 251   }
 252   free(value);
 253
 254   return 0;
 255 }
 256
 257 uint8_t cas2_test(memcached_st *memc)
 258 {
 259   memcached_return rc;
 260   char *keys[]= {"fudge", "son", "food"};
 261   size_t key_length[]= {5, 3, 4};
 262   char *value= "we the people";
 263   size_t value_length= strlen("we the people");
 264   unsigned int x;
 265   memcached_result_st results_obj;
 266   memcached_result_st *results;
 267   unsigned int set= 1;
 268
 269   rc= memcached_flush(memc, 0);
 270   assert(rc == MEMCACHED_SUCCESS);
 271
 272   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 273
 274   for (x= 0; x < 3; x++)
 275   {
 276     rc= memcached_set(memc, keys[x], key_length[x],
 277                       keys[x], key_length[x],
 278                       (time_t)50, (uint32_t)9);
 279     assert(rc == MEMCACHED_SUCCESS);
 280   }
 281
 282   rc= memcached_mget(memc, keys, key_length, 3);
 283
 284   results= memcached_result_create(memc, &results_obj);
 285
 286   results= memcached_fetch_result(memc, &results_obj, &rc);
 287   assert(results);
 288   assert(results->cas);
 289   assert(rc == MEMCACHED_SUCCESS);
 290   WATCHPOINT_ASSERT(memcached_result_cas(results));
 291
 292   assert(!memcmp(value, "we the people", strlen("we the people")));
 293   assert(strlen("we the people") == value_length);
 294   assert(rc == MEMCACHED_SUCCESS);
 295
 296   memcached_result_free(&results_obj);
 297
 298   return 0;
 299 }
 300
 301 uint8_t cas_test(memcached_st *memc)
 302 {
 303   memcached_return rc;
 304   char *key= "fun";
 305   size_t key_length= strlen("fun");
 306   char *value= "we the people";
 307   size_t value_length= strlen("we the people");
 308   memcached_result_st results_obj;
 309   memcached_result_st *results;
 310   unsigned int set= 1;
 311
 312   rc= memcached_flush(memc, 0);
 313   assert(rc == MEMCACHED_SUCCESS);
 314
 315   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
 316
 317   rc= memcached_set(memc, key, strlen(key),
 318                     value, strlen(value),
 319                     (time_t)0, (uint32_t)0);
 320   assert(rc == MEMCACHED_SUCCESS);
 321
 322   rc= memcached_mget(memc, &key, &key_length, 1);
 323
 324   results= memcached_result_create(memc, &results_obj);
 325
 326   results= memcached_fetch_result(memc, &results_obj, &rc);
 327   assert(results);
 328   assert(rc == MEMCACHED_SUCCESS);
 329   WATCHPOINT_ASSERT(memcached_result_cas(results));
 330
 331   assert(!memcmp(value, "we the people", strlen("we the people")));
 332   assert(strlen("we the people") == value_length);
 333   assert(rc == MEMCACHED_SUCCESS);
 334
 335   rc= memcached_cas(memc, key, key_length,
 336                     "change the value", strlen("change the value"),
 337                     0, 0, memcached_result_cas(results));
 338
 339   assert(rc == MEMCACHED_SUCCESS);
 340
 341   rc= memcached_cas(memc, key, key_length,
 342                     "change the value", strlen("change the value"),
 343                     0, 0, 23);
 344
 345   assert(rc == MEMCACHED_DATA_EXISTS);
 346
 347
 348   memcached_result_free(&results_obj);
 349
 350   return 0;
 351 }
 352
 353 uint8_t prepend_test(memcached_st *memc)
 354 {
 355   memcached_return rc;
 356   char *key= "fig";
 357   char *value= "people";
 358   size_t value_length;
 359   uint32_t flags;
 360
 361   rc= memcached_flush(memc, 0);
 362   assert(rc == MEMCACHED_SUCCESS);
 363
 364   rc= memcached_set(memc, key, strlen(key),
 365                     value, strlen(value),
 366                     (time_t)0, (uint32_t)0);
 367   assert(rc == MEMCACHED_SUCCESS);
 368
 369   rc= memcached_prepend(memc, key, strlen(key),
 370                        "the ", strlen("the "),
 371                        (time_t)0, (uint32_t)0);
 372   assert(rc == MEMCACHED_SUCCESS);
 373
 374   rc= memcached_prepend(memc, key, strlen(key),
 375                        "we ", strlen("we "),
 376                        (time_t)0, (uint32_t)0);
 377   assert(rc == MEMCACHED_SUCCESS);
 378
 379   value= memcached_get(memc, key, strlen(key),
 380                        &value_length, &flags, &rc);
 381   assert(!memcmp(value, "we the people", strlen("we the people")));
 382   assert(strlen("we the people") == value_length);
 383   assert(rc == MEMCACHED_SUCCESS);
 384   free(value);
 385
 386   return 0;
 387 }
 388
 389 /*
 390   Set the value, then quit to make sure it is flushed.
 391   Come back in and test that add fails.
 392 */
 393 uint8_t add_test(memcached_st *memc)
 394 {
 395   memcached_return rc;
 396   char *key= "foo";
 397   char *value= "when we sanitize";
 398   unsigned long long setting_value;
 399
 400   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 401
 402   rc= memcached_set(memc, key, strlen(key),
 403                     value, strlen(value),
 404                     (time_t)0, (uint32_t)0);
 405   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 406   memcached_quit(memc);
 407   rc= memcached_add(memc, key, strlen(key),
 408                     value, strlen(value),
 409                     (time_t)0, (uint32_t)0);
 410
 411   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 412   if (setting_value)
 413     assert(rc == MEMCACHED_NOTSTORED || MEMCACHED_STORED);
 414   else
 415     assert(rc == MEMCACHED_NOTSTORED);
 416
 417   return 0;
 418 }
 419
 420 uint8_t add_wrapper(memcached_st *memc)
 421 {
 422   unsigned int x;
 423
 424   for (x= 0; x < 10000; x++)
 425     add_test(memc);
 426
 427   return 0;
 428 }
 429
 430 uint8_t replace_test(memcached_st *memc)
 431 {
 432   memcached_return rc;
 433   char *key= "foo";
 434   char *value= "when we sanitize";
 435   char *original= "first we insert some data";
 436
 437   rc= memcached_set(memc, key, strlen(key),
 438                     original, strlen(original),
 439                     (time_t)0, (uint32_t)0);
 440   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 441
 442   rc= memcached_replace(memc, key, strlen(key),
 443                     value, strlen(value),
 444                     (time_t)0, (uint32_t)0);
 445   assert(rc == MEMCACHED_SUCCESS);
 446
 447   return 0;
 448 }
 449
 450 uint8_t delete_test(memcached_st *memc)
 451 {
 452   memcached_return rc;
 453   char *key= "foo";
 454   char *value= "when we sanitize";
 455
 456   rc= memcached_set(memc, key, strlen(key),
 457                     value, strlen(value),
 458                     (time_t)0, (uint32_t)0);
 459   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 460
 461   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 462   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 463
 464   return 0;
 465 }
 466
 467 uint8_t flush_test(memcached_st *memc)
 468 {
 469   memcached_return rc;
 470
 471   rc= memcached_flush(memc, 0);
 472   assert(rc == MEMCACHED_SUCCESS);
 473
 474   return 0;
 475 }
 476
 477 memcached_return server_function(memcached_st *ptr, memcached_server_st *server, void *context)
 478 {
 479   /* Do Nothing */
 480
 481   return MEMCACHED_SUCCESS;
 482 }
 483
 484 uint8_t memcached_server_cursor_test(memcached_st *memc)
 485 {
 486   char *context= "foo bad";
 487   memcached_server_function callbacks[1];
 488
 489   callbacks[0]= server_function;
 490   memcached_server_cursor(memc, callbacks, context,  1);
 491
 492   return 0;
 493 }
 494
 495 uint8_t bad_key_test(memcached_st *memc)
 496 {
 497   memcached_return rc;
 498   char *key= "foo bad";
 499   char *string;
 500   size_t string_length;
 501   uint32_t flags;
 502   memcached_st *clone;
 503   unsigned int set= 1;
 504
 505   clone= memcached_clone(NULL, memc);
 506   assert(clone);
 507
 508   (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, &set);
 509
 510   string= memcached_get(clone, key, strlen(key),
 511                         &string_length, &flags, &rc);
 512   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 513   assert(string_length ==  0);
 514   assert(!string);
 515
 516   set= 0;
 517   (void)memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, &set);
 518   string= memcached_get(clone, key, strlen(key),
 519                         &string_length, &flags, &rc);
 520   assert(rc == MEMCACHED_NOTFOUND);
 521   assert(string_length ==  0);
 522   assert(!string);
 523
 524   memcached_free(clone);
 525
 526   return 0;
 527 }
 528
 529 uint8_t get_test(memcached_st *memc)
 530 {
 531   memcached_return rc;
 532   char *key= "foo";
 533   char *string;
 534   size_t string_length;
 535   uint32_t flags;
 536
 537   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 538   assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 539
 540   string= memcached_get(memc, key, strlen(key),
 541                         &string_length, &flags, &rc);
 542
 543   assert(rc == MEMCACHED_NOTFOUND);
 544   assert(string_length ==  0);
 545   assert(!string);
 546
 547   return 0;
 548 }
 549
 550 uint8_t get_test2(memcached_st *memc)
 551 {
 552   memcached_return rc;
 553   char *key= "foo";
 554   char *value= "when we sanitize";
 555   char *string;
 556   size_t string_length;
 557   uint32_t flags;
 558
 559   rc= memcached_set(memc, key, strlen(key),
 560                     value, strlen(value),
 561                     (time_t)0, (uint32_t)0);
 562   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 563
 564   string= memcached_get(memc, key, strlen(key),
 565                         &string_length, &flags, &rc);
 566
 567   assert(string);
 568   assert(rc == MEMCACHED_SUCCESS);
 569   assert(string_length == strlen(value));
 570   assert(!memcmp(string, value, string_length));
 571
 572   free(string);
 573
 574   return 0;
 575 }
 576
 577 uint8_t set_test2(memcached_st *memc)
 578 {
 579   memcached_return rc;
 580   char *key= "foo";
 581   char *value= "train in the brain";
 582   size_t value_length= strlen(value);
 583   unsigned int x;
 584
 585   for (x= 0; x < 10; x++)
 586   {
 587     rc= memcached_set(memc, key, strlen(key),
 588                       value, value_length,
 589                       (time_t)0, (uint32_t)0);
 590     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 591   }
 592
 593   return 0;
 594 }
 595
 596 uint8_t set_test3(memcached_st *memc)
 597 {
 598   memcached_return rc;
 599   char *key= "foo";
 600   char *value;
 601   size_t value_length= 8191;
 602   unsigned int x;
 603
 604   value = (char*)malloc(value_length);
 605   assert(value);
 606
 607   for (x= 0; x < value_length; x++)
 608     value[x] = (char) (x % 127);
 609
 610   for (x= 0; x < 1; x++)
 611   {
 612     rc= memcached_set(memc, key, strlen(key),
 613                       value, value_length,
 614                       (time_t)0, (uint32_t)0);
 615     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 616   }
 617
 618   free(value);
 619
 620   return 0;
 621 }
 622
 623 uint8_t get_test3(memcached_st *memc)
 624 {
 625   memcached_return rc;
 626   char *key= "foo";
 627   char *value;
 628   size_t value_length= 8191;
 629   char *string;
 630   size_t string_length;
 631   uint32_t flags;
 632   int x;
 633
 634   value = (char*)malloc(value_length);
 635   assert(value);
 636
 637   for (x= 0; x < value_length; x++)
 638     value[x] = (char) (x % 127);
 639
 640   rc= memcached_set(memc, key, strlen(key),
 641                     value, value_length,
 642                     (time_t)0, (uint32_t)0);
 643   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 644
 645   string= memcached_get(memc, key, strlen(key),
 646                         &string_length, &flags, &rc);
 647
 648   assert(rc == MEMCACHED_SUCCESS);
 649   assert(string);
 650   assert(string_length == value_length);
 651   assert(!memcmp(string, value, string_length));
 652
 653   free(string);
 654   free(value);
 655
 656   return 0;
 657 }
 658
 659 uint8_t get_test4(memcached_st *memc)
 660 {
 661   memcached_return rc;
 662   char *key= "foo";
 663   char *value;
 664   size_t value_length= 8191;
 665   char *string;
 666   size_t string_length;
 667   uint32_t flags;
 668   int x;
 669
 670   value = (char*)malloc(value_length);
 671   assert(value);
 672
 673   for (x= 0; x < value_length; x++)
 674     value[x] = (char) (x % 127);
 675
 676   rc= memcached_set(memc, key, strlen(key),
 677                     value, value_length,
 678                     (time_t)0, (uint32_t)0);
 679   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 680
 681   for (x= 0; x < 10; x++)
 682   {
 683     string= memcached_get(memc, key, strlen(key),
 684                           &string_length, &flags, &rc);
 685
 686     assert(rc == MEMCACHED_SUCCESS);
 687     assert(string);
 688     assert(string_length == value_length);
 689     assert(!memcmp(string, value, string_length));
 690     free(string);
 691   }
 692
 693   free(value);
 694
 695   return 0;
 696 }
 697
 698 /* Do not copy the style of this code, I just access hosts to testthis function */
 699 uint8_t stats_servername_test(memcached_st *memc)
 700 {
 701   memcached_return rc;
 702   memcached_stat_st stat;
 703   rc= memcached_stat_servername(&stat, NULL,
 704                                  memc->hosts[0].hostname,
 705                                  memc->hosts[0].port);
 706
 707   return 0;
 708 }
 709
 710 uint8_t increment_test(memcached_st *memc)
 711 {
 712   uint64_t new_number;
 713   memcached_return rc;
 714   char *key= "number";
 715   char *value= "0";
 716
 717   rc= memcached_set(memc, key, strlen(key),
 718                     value, strlen(value),
 719                     (time_t)0, (uint32_t)0);
 720   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 721
 722   rc= memcached_increment(memc, key, strlen(key),
 723                           1, &new_number);
 724   assert(rc == MEMCACHED_SUCCESS);
 725   assert(new_number == 1);
 726
 727   rc= memcached_increment(memc, key, strlen(key),
 728                           1, &new_number);
 729   assert(rc == MEMCACHED_SUCCESS);
 730   assert(new_number == 2);
 731
 732   return 0;
 733 }
 734
 735 uint8_t decrement_test(memcached_st *memc)
 736 {
 737   uint64_t new_number;
 738   memcached_return rc;
 739   char *key= "number";
 740   char *value= "3";
 741
 742   rc= memcached_set(memc, key, strlen(key),
 743                     value, strlen(value),
 744                     (time_t)0, (uint32_t)0);
 745   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 746
 747   rc= memcached_decrement(memc, key, strlen(key),
 748                           1, &new_number);
 749   assert(rc == MEMCACHED_SUCCESS);
 750   assert(new_number == 2);
 751
 752   rc= memcached_decrement(memc, key, strlen(key),
 753                           1, &new_number);
 754   assert(rc == MEMCACHED_SUCCESS);
 755   assert(new_number == 1);
 756
 757   return 0;
 758 }
 759
 760 uint8_t quit_test(memcached_st *memc)
 761 {
 762   memcached_return rc;
 763   char *key= "fudge";
 764   char *value= "sanford and sun";
 765
 766   rc= memcached_set(memc, key, strlen(key),
 767                     value, strlen(value),
 768                     (time_t)10, (uint32_t)3);
 769   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 770   memcached_quit(memc);
 771
 772   rc= memcached_set(memc, key, strlen(key),
 773                     value, strlen(value),
 774                     (time_t)50, (uint32_t)9);
 775   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 776
 777   return 0;
 778 }
 779
 780 uint8_t mget_result_test(memcached_st *memc)
 781 {
 782   memcached_return rc;
 783   char *keys[]= {"fudge", "son", "food"};
 784   size_t key_length[]= {5, 3, 4};
 785   unsigned int x;
 786
 787   memcached_result_st results_obj;
 788   memcached_result_st *results;
 789
 790   results= memcached_result_create(memc, &results_obj);
 791   assert(results);
 792   assert(&results_obj == results);
 793
 794   /* We need to empty the server before continueing test */
 795   rc= memcached_flush(memc, 0);
 796   assert(rc == MEMCACHED_SUCCESS);
 797
 798   rc= memcached_mget(memc, keys, key_length, 3);
 799   assert(rc == MEMCACHED_SUCCESS);
 800
 801   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 802   {
 803     assert(results);
 804   }
 805
 806   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
 807   assert(!results);
 808   assert(rc == MEMCACHED_END);
 809
 810   for (x= 0; x < 3; x++)
 811   {
 812     rc= memcached_set(memc, keys[x], key_length[x],
 813                       keys[x], key_length[x],
 814                       (time_t)50, (uint32_t)9);
 815     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 816   }
 817
 818   rc= memcached_mget(memc, keys, key_length, 3);
 819   assert(rc == MEMCACHED_SUCCESS);
 820
 821   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
 822   {
 823     assert(results);
 824     assert(&results_obj == results);
 825     assert(rc == MEMCACHED_SUCCESS);
 826     assert(memcached_result_key_length(results) == memcached_result_length(results));
 827     assert(!memcmp(memcached_result_key_value(results),
 828                    memcached_result_value(results),
 829                    memcached_result_length(results)));
 830   }
 831
 832   memcached_result_free(&results_obj);
 833
 834   return 0;
 835 }
 836
 837 uint8_t mget_result_alloc_test(memcached_st *memc)
 838 {
 839   memcached_return rc;
 840   char *keys[]= {"fudge", "son", "food"};
 841   size_t key_length[]= {5, 3, 4};
 842   unsigned int x;
 843
 844   memcached_result_st *results;
 845
 846   /* We need to empty the server before continueing test */
 847   rc= memcached_flush(memc, 0);
 848   assert(rc == MEMCACHED_SUCCESS);
 849
 850   rc= memcached_mget(memc, keys, key_length, 3);
 851   assert(rc == MEMCACHED_SUCCESS);
 852
 853   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
 854   {
 855     assert(results);
 856   }
 857   assert(!results);
 858   assert(rc == MEMCACHED_END);
 859
 860   for (x= 0; x < 3; x++)
 861   {
 862     rc= memcached_set(memc, keys[x], key_length[x],
 863                       keys[x], key_length[x],
 864                       (time_t)50, (uint32_t)9);
 865     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 866   }
 867
 868   rc= memcached_mget(memc, keys, key_length, 3);
 869   assert(rc == MEMCACHED_SUCCESS);
 870
 871   x= 0;
 872   while ((results= memcached_fetch_result(memc, NULL, &rc)))
 873   {
 874     assert(results);
 875     assert(rc == MEMCACHED_SUCCESS);
 876     assert(memcached_result_key_length(results) == memcached_result_length(results));
 877     assert(!memcmp(memcached_result_key_value(results),
 878                    memcached_result_value(results),
 879                    memcached_result_length(results)));
 880     memcached_result_free(results);
 881     x++;
 882   }
 883
 884   return 0;
 885 }
 886
 887 /* Count the results */
 888 unsigned int callback_counter(memcached_st *ptr, memcached_result_st *result, void *context)
 889 {
 890   unsigned int *counter= (unsigned int *)context;
 891
 892   *counter= *counter + 1;
 893
 894   return 0;
 895 }
 896
 897 uint8_t mget_result_function(memcached_st *memc)
 898 {
 899   memcached_return rc;
 900   char *keys[]= {"fudge", "son", "food"};
 901   size_t key_length[]= {5, 3, 4};
 902   unsigned int x;
 903   unsigned int counter;
 904   memcached_execute_function callbacks[1];
 905
 906   /* We need to empty the server before continueing test */
 907   rc= memcached_flush(memc, 0);
 908   for (x= 0; x < 3; x++)
 909   {
 910     rc= memcached_set(memc, keys[x], key_length[x],
 911                       keys[x], key_length[x],
 912                       (time_t)50, (uint32_t)9);
 913     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 914   }
 915
 916   rc= memcached_mget(memc, keys, key_length, 3);
 917   assert(rc == MEMCACHED_SUCCESS);
 918
 919   callbacks[0]= &callback_counter;
 920   counter= 0;
 921   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
 922
 923   assert(counter == 3);
 924
 925   return 0;
 926 }
 927
 928 uint8_t mget_test(memcached_st *memc)
 929 {
 930   memcached_return rc;
 931   char *keys[]= {"fudge", "son", "food"};
 932   size_t key_length[]= {5, 3, 4};
 933   unsigned int x;
 934   uint32_t flags;
 935
 936   char return_key[MEMCACHED_MAX_KEY];
 937   size_t return_key_length;
 938   char *return_value;
 939   size_t return_value_length;
 940
 941   /* We need to empty the server before continueing test */
 942   rc= memcached_flush(memc, 0);
 943   assert(rc == MEMCACHED_SUCCESS);
 944
 945   rc= memcached_mget(memc, keys, key_length, 3);
 946   assert(rc == MEMCACHED_SUCCESS);
 947
 948   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 949                       &return_value_length, &flags, &rc)) != NULL)
 950   {
 951     assert(return_value);
 952   }
 953   assert(!return_value);
 954   assert(return_value_length == 0);
 955   assert(rc == MEMCACHED_END);
 956
 957   for (x= 0; x < 3; x++)
 958   {
 959     rc= memcached_set(memc, keys[x], key_length[x],
 960                       keys[x], key_length[x],
 961                       (time_t)50, (uint32_t)9);
 962     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 963   }
 964
 965   rc= memcached_mget(memc, keys, key_length, 3);
 966   assert(rc == MEMCACHED_SUCCESS);
 967
 968   x= 0;
 969   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
 970                                         &return_value_length, &flags, &rc)))
 971   {
 972     assert(return_value);
 973     assert(rc == MEMCACHED_SUCCESS);
 974     assert(return_key_length == return_value_length);
 975     assert(!memcmp(return_value, return_key, return_value_length));
 976     free(return_value);
 977     x++;
 978   }
 979
 980   return 0;
 981 }
 982
 983 uint8_t get_stats_keys(memcached_st *memc)
 984 {
 985  char **list;
 986  char **ptr;
 987  memcached_stat_st stat;
 988  memcached_return rc;
 989
 990  list= memcached_stat_get_keys(memc, &stat, &rc);
 991  assert(rc == MEMCACHED_SUCCESS);
 992  for (ptr= list; *ptr; ptr++)
 993    assert(*ptr);
 994  fflush(stdout);
 995
 996  free(list);
 997
 998  return 0;
 999 }
1000
1001 uint8_t version_string_test(memcached_st *memc)
1002 {
1003   const char *version_string;
1004
1005   version_string= memcached_lib_version();
1006
1007   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1008
1009   return 0;
1010 }
1011
1012 uint8_t get_stats(memcached_st *memc)
1013 {
1014  unsigned int x;
1015  char **list;
1016  char **ptr;
1017  memcached_return rc;
1018  memcached_stat_st *stat;
1019
1020  stat= memcached_stat(memc, NULL, &rc);
1021  assert(rc == MEMCACHED_SUCCESS);
1022
1023  assert(rc == MEMCACHED_SUCCESS);
1024  assert(stat);
1025
1026  for (x= 0; x < memcached_server_count(memc); x++)
1027  {
1028    list= memcached_stat_get_keys(memc, stat+x, &rc);
1029    assert(rc == MEMCACHED_SUCCESS);
1030    for (ptr= list; *ptr; ptr++);
1031
1032    free(list);
1033  }
1034
1035  memcached_stat_free(NULL, stat);
1036
1037   return 0;
1038 }
1039
1040 uint8_t add_host_test(memcached_st *memc)
1041 {
1042   unsigned int x;
1043   memcached_server_st *servers;
1044   memcached_return rc;
1045   char servername[]= "0.example.com";
1046
1047   servers= memcached_server_list_append(NULL, servername, 400, &rc);
1048   assert(servers);
1049   assert(1 == memcached_server_list_count(servers));
1050
1051   for (x= 2; x < 20; x++)
1052   {
1053     char buffer[SMALL_STRING_LEN];
1054
1055     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1056     servers= memcached_server_list_append(servers, buffer, 401,
1057                                      &rc);
1058     assert(rc == MEMCACHED_SUCCESS);
1059     assert(x == memcached_server_list_count(servers));
1060   }
1061
1062   rc= memcached_server_push(memc, servers);
1063   assert(rc == MEMCACHED_SUCCESS);
1064   rc= memcached_server_push(memc, servers);
1065   assert(rc == MEMCACHED_SUCCESS);
1066
1067   memcached_server_list_free(servers);
1068
1069   return 0;
1070 }
1071
1072 memcached_return clone_test_callback(memcached_st *parent, memcached_st *clone)
1073 {
1074   return MEMCACHED_SUCCESS;
1075 }
1076
1077 memcached_return cleanup_test_callback(memcached_st *ptr)
1078 {
1079   return MEMCACHED_SUCCESS;
1080 }
1081
1082 uint8_t callback_test(memcached_st *memc)
1083 {
1084   /* Test User Data */
1085   {
1086     int x= 5;
1087     int *test_ptr;
1088     memcached_return rc;
1089
1090     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1091     assert(rc == MEMCACHED_SUCCESS);
1092     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1093     assert(*test_ptr == x);
1094   }
1095
1096   /* Test Clone Callback */
1097   {
1098     memcached_clone_func temp_function;
1099     memcached_return rc;
1100
1101     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_test_callback);
1102     assert(rc == MEMCACHED_SUCCESS);
1103     temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1104     assert(temp_function == clone_test_callback);
1105   }
1106
1107   /* Test Cleanup Callback */
1108   {
1109     memcached_cleanup_func temp_function;
1110     memcached_return rc;
1111
1112     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_test_callback);
1113     assert(rc == MEMCACHED_SUCCESS);
1114     temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1115     assert(temp_function == cleanup_test_callback);
1116   }
1117
1118   return 0;
1119 }
1120
1121 /* We don't test the behavior itself, we test the switches */
1122 uint8_t behavior_test(memcached_st *memc)
1123 {
1124   unsigned long long value;
1125   unsigned int set= 1;
1126
1127   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1128   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1129   assert(value == 1);
1130
1131   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1132   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1133   assert(value == 1);
1134
1135   set= MEMCACHED_HASH_MD5;
1136   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
1137   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1138   assert(value == MEMCACHED_HASH_MD5);
1139
1140   set= 0;
1141
1142   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1143   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1144   assert(value == 0);
1145
1146   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1147   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1148   assert(value == 0);
1149
1150   set= MEMCACHED_HASH_DEFAULT;
1151   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
1152   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1153   assert(value == MEMCACHED_HASH_DEFAULT);
1154
1155   set= MEMCACHED_HASH_CRC;
1156   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &set);
1157   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1158   assert(value == MEMCACHED_HASH_CRC);
1159
1160   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1161   assert(value > 0);
1162
1163   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1164   assert(value > 0);
1165
1166   return 0;
1167 }
1168
1169 /* Test case provided by Cal Haldenbrand */
1170 uint8_t user_supplied_bug1(memcached_st *memc)
1171 {
1172   unsigned int setter= 1;
1173   unsigned int x;
1174
1175   unsigned long long total= 0;
1176   int size= 0;
1177   char key[10];
1178   char randomstuff[6 * 1024];
1179   memcached_return rc;
1180
1181   memset(randomstuff, 0, 6 * 1024);
1182
1183   /* We just keep looking at the same values over and over */
1184   srandom(10);
1185
1186   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1187   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1188
1189
1190   /* add key */
1191   for (x= 0 ; total < 20 * 1024576 ; x++ )
1192   {
1193     unsigned int j= 0;
1194
1195     size= (rand() % ( 5 * 1024 ) ) + 400;
1196     memset(randomstuff, 0, 6 * 1024);
1197     assert(size < 6 * 1024); /* Being safe here */
1198
1199     for (j= 0 ; j < size ;j++)
1200       randomstuff[j] = (char) (rand() % 26) + 97;
1201
1202     total += size;
1203     sprintf(key, "%d", x);
1204     rc = memcached_set(memc, key, strlen(key),
1205                        randomstuff, strlen(randomstuff), 10, 0);
1206     /* If we fail, lets try again */
1207     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1208       rc = memcached_set(memc, key, strlen(key),
1209                          randomstuff, strlen(randomstuff), 10, 0);
1210     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1211   }
1212
1213   return 0;
1214 }
1215
1216 /* Test case provided by Cal Haldenbrand */
1217 uint8_t user_supplied_bug2(memcached_st *memc)
1218 {
1219   int errors;
1220   unsigned int setter;
1221   unsigned int x;
1222   unsigned long long total;
1223
1224   setter= 1;
1225   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1226   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1227 #ifdef NOT_YET
1228   setter = 20 * 1024576;
1229   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1230   setter = 20 * 1024576;
1231   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1232   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1233   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1234
1235   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1236 #endif
1237
1238   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1239   {
1240     memcached_return rc= MEMCACHED_SUCCESS;
1241     char buffer[SMALL_STRING_LEN];
1242     uint32_t flags= 0;
1243     size_t val_len= 0;
1244     char *getval;
1245
1246     memset(buffer, 0, SMALL_STRING_LEN);
1247
1248     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1249     getval= memcached_get(memc, buffer, strlen(buffer),
1250                            &val_len, &flags, &rc);
1251     if (rc != MEMCACHED_SUCCESS)
1252     {
1253       if (rc == MEMCACHED_NOTFOUND)
1254         errors++;
1255       else
1256       {
1257         WATCHPOINT_ERROR(rc);
1258         assert(0);
1259       }
1260
1261       continue;
1262     }
1263     total+= val_len;
1264     errors= 0;
1265     free(getval);
1266   }
1267
1268   return 0;
1269 }
1270
1271 /* Do a large mget() over all the keys we think exist */
1272 #define KEY_COUNT 3000 // * 1024576
1273 uint8_t user_supplied_bug3(memcached_st *memc)
1274 {
1275   memcached_return rc;
1276   unsigned int setter;
1277   unsigned int x;
1278   char **keys;
1279   size_t key_lengths[KEY_COUNT];
1280
1281   setter= 1;
1282   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, &setter);
1283   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1284 #ifdef NOT_YET
1285   setter = 20 * 1024576;
1286   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, &setter);
1287   setter = 20 * 1024576;
1288   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, &setter);
1289   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1290   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1291 #endif
1292
1293   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1294   assert(keys);
1295   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1296   for (x= 0; x < KEY_COUNT; x++)
1297   {
1298     char buffer[30];
1299
1300     snprintf(buffer, 30, "%u", x);
1301     keys[x]= strdup(buffer);
1302     key_lengths[x]= strlen(keys[x]);
1303   }
1304
1305   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1306   assert(rc == MEMCACHED_SUCCESS);
1307
1308   /* Turn this into a help function */
1309   {
1310     char return_key[MEMCACHED_MAX_KEY];
1311     size_t return_key_length;
1312     char *return_value;
1313     size_t return_value_length;
1314     uint32_t flags;
1315
1316     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1317                                           &return_value_length, &flags, &rc)))
1318     {
1319       assert(return_value);
1320       assert(rc == MEMCACHED_SUCCESS);
1321       free(return_value);
1322     }
1323   }
1324
1325   for (x= 0; x < KEY_COUNT; x++)
1326     free(keys[x]);
1327   free(keys);
1328
1329   return 0;
1330 }
1331
1332 /* Make sure we behave properly if server list has no values */
1333 uint8_t user_supplied_bug4(memcached_st *memc)
1334 {
1335   memcached_return rc;
1336   char *keys[]= {"fudge", "son", "food"};
1337   size_t key_length[]= {5, 3, 4};
1338   unsigned int x;
1339   uint32_t flags;
1340   char return_key[MEMCACHED_MAX_KEY];
1341   size_t return_key_length;
1342   char *return_value;
1343   size_t return_value_length;
1344
1345   /* Here we free everything before running a bunch of mget tests */
1346   {
1347     memcached_server_list_free(memc->hosts);
1348     memc->hosts= NULL;
1349     memc->number_of_hosts= 0;
1350   }
1351
1352
1353   /* We need to empty the server before continueing test */
1354   rc= memcached_flush(memc, 0);
1355   assert(rc == MEMCACHED_NO_SERVERS);
1356
1357   rc= memcached_mget(memc, keys, key_length, 3);
1358   assert(rc == MEMCACHED_NO_SERVERS);
1359
1360   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1361                       &return_value_length, &flags, &rc)) != NULL)
1362   {
1363     assert(return_value);
1364   }
1365   assert(!return_value);
1366   assert(return_value_length == 0);
1367   assert(rc == MEMCACHED_NO_SERVERS);
1368
1369   for (x= 0; x < 3; x++)
1370   {
1371     rc= memcached_set(memc, keys[x], key_length[x],
1372                       keys[x], key_length[x],
1373                       (time_t)50, (uint32_t)9);
1374     assert(rc == MEMCACHED_NO_SERVERS);
1375   }
1376
1377   rc= memcached_mget(memc, keys, key_length, 3);
1378   assert(rc == MEMCACHED_NO_SERVERS);
1379
1380   x= 0;
1381   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1382                                         &return_value_length, &flags, &rc)))
1383   {
1384     assert(return_value);
1385     assert(rc == MEMCACHED_SUCCESS);
1386     assert(return_key_length == return_value_length);
1387     assert(!memcmp(return_value, return_key, return_value_length));
1388     free(return_value);
1389     x++;
1390   }
1391
1392   return 0;
1393 }
1394
1395 #define VALUE_SIZE_BUG5 1048064
1396 uint8_t user_supplied_bug5(memcached_st *memc)
1397 {
1398   memcached_return rc;
1399   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1400   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1401   char return_key[MEMCACHED_MAX_KEY];
1402   size_t return_key_length;
1403   char *value;
1404   size_t value_length;
1405   uint32_t flags;
1406   unsigned int count;
1407   unsigned int x;
1408   char insert_data[VALUE_SIZE_BUG5];
1409
1410   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1411     insert_data[x]= rand();
1412
1413   memcached_flush(memc, 0);
1414   value= memcached_get(memc, keys[0], key_length[0],
1415                         &value_length, &flags, &rc);
1416   assert(value == NULL);
1417   rc= memcached_mget(memc, keys, key_length, 4);
1418
1419   count= 0;
1420   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1421                                         &value_length, &flags, &rc)))
1422     count++;
1423   assert(count == 0);
1424
1425   for (x= 0; x < 4; x++)
1426   {
1427     rc= memcached_set(memc, keys[x], key_length[x],
1428                       insert_data, VALUE_SIZE_BUG5,
1429                       (time_t)0, (uint32_t)0);
1430     assert(rc == MEMCACHED_SUCCESS);
1431   }
1432
1433   for (x= 0; x < 10; x++)
1434   {
1435     value= memcached_get(memc, keys[0], key_length[0],
1436                          &value_length, &flags, &rc);
1437     assert(value);
1438     free(value);
1439
1440     rc= memcached_mget(memc, keys, key_length, 4);
1441     count= 0;
1442     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1443                                           &value_length, &flags, &rc)))
1444     {
1445       count++;
1446       free(value);
1447     }
1448     assert(count == 4);
1449   }
1450
1451   return 0;
1452 }
1453
1454 uint8_t user_supplied_bug6(memcached_st *memc)
1455 {
1456   memcached_return rc;
1457   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1458   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1459   char return_key[MEMCACHED_MAX_KEY];
1460   size_t return_key_length;
1461   char *value;
1462   size_t value_length;
1463   uint32_t flags;
1464   unsigned int count;
1465   unsigned int x;
1466   char insert_data[VALUE_SIZE_BUG5];
1467
1468   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1469     insert_data[x]= rand();
1470
1471   memcached_flush(memc, 0);
1472   value= memcached_get(memc, keys[0], key_length[0],
1473                         &value_length, &flags, &rc);
1474   assert(value == NULL);
1475   assert(rc == MEMCACHED_NOTFOUND);
1476   rc= memcached_mget(memc, keys, key_length, 4);
1477   assert(rc == MEMCACHED_SUCCESS);
1478
1479   count= 0;
1480   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1481                                         &value_length, &flags, &rc)))
1482     count++;
1483   assert(count == 0);
1484   assert(rc == MEMCACHED_END);
1485
1486   for (x= 0; x < 4; x++)
1487   {
1488     rc= memcached_set(memc, keys[x], key_length[x],
1489                       insert_data, VALUE_SIZE_BUG5,
1490                       (time_t)0, (uint32_t)0);
1491     assert(rc == MEMCACHED_SUCCESS);
1492   }
1493
1494   for (x= 0; x < 2; x++)
1495   {
1496     value= memcached_get(memc, keys[0], key_length[0],
1497                          &value_length, &flags, &rc);
1498     assert(value);
1499     free(value);
1500
1501     rc= memcached_mget(memc, keys, key_length, 4);
1502     assert(rc == MEMCACHED_SUCCESS);
1503     count= 3;
1504     /* We test for purge of partial complete fetches */
1505     for (count= 3; count; count--)
1506     {
1507       value= memcached_fetch(memc, return_key, &return_key_length,
1508                              &value_length, &flags, &rc);
1509       assert(rc == MEMCACHED_SUCCESS);
1510       assert(!(memcmp(value, insert_data, value_length)));
1511       assert(value_length);
1512       free(value);
1513     }
1514   }
1515
1516   return 0;
1517 }
1518
1519 uint8_t user_supplied_bug8(memcached_st *memc)
1520 {
1521   memcached_return rc;
1522   memcached_st *mine;
1523   memcached_st *clone;
1524
1525   memcached_server_st *servers;
1526   char *server_list= "memcache1.memcache.bk.sapo.pt:11211, memcache1.memcache.bk.sapo.pt:11212, memcache1.memcache.bk.sapo.pt:11213, memcache1.memcache.bk.sapo.pt:11214, memcache2.memcache.bk.sapo.pt:11211, memcache2.memcache.bk.sapo.pt:11212, memcache2.memcache.bk.sapo.pt:11213, memcache2.memcache.bk.sapo.pt:11214";
1527
1528   servers= memcached_servers_parse(server_list);
1529   assert(servers);
1530
1531   mine= memcached_create(NULL);
1532   rc= memcached_server_push(mine, servers);
1533   assert(rc == MEMCACHED_SUCCESS);
1534   memcached_server_list_free(servers);
1535
1536   assert(mine);
1537   clone= memcached_clone(NULL, mine);
1538
1539   memcached_quit(mine);
1540   memcached_quit(clone);
1541
1542
1543   memcached_free(mine);
1544   memcached_free(clone);
1545
1546   return 0;
1547 }
1548
1549 /* Test flag store/retrieve */
1550 uint8_t user_supplied_bug7(memcached_st *memc)
1551 {
1552   memcached_return rc;
1553   char *keys= "036790384900";
1554   size_t key_length=  strlen("036790384900");
1555   char return_key[MEMCACHED_MAX_KEY];
1556   size_t return_key_length;
1557   char *value;
1558   size_t value_length;
1559   uint32_t flags;
1560   unsigned int x;
1561   char insert_data[VALUE_SIZE_BUG5];
1562
1563   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1564     insert_data[x]= rand();
1565
1566   memcached_flush(memc, 0);
1567
1568   flags= 245;
1569   rc= memcached_set(memc, keys, key_length,
1570                     insert_data, VALUE_SIZE_BUG5,
1571                     (time_t)0, flags);
1572   assert(rc == MEMCACHED_SUCCESS);
1573
1574   flags= 0;
1575   value= memcached_get(memc, keys, key_length,
1576                         &value_length, &flags, &rc);
1577   assert(flags == 245);
1578   assert(value);
1579   free(value);
1580
1581   rc= memcached_mget(memc, &keys, &key_length, 1);
1582
1583   flags= 0;
1584   value= memcached_fetch(memc, return_key, &return_key_length,
1585                          &value_length, &flags, &rc);
1586   assert(flags == 245);
1587   assert(value);
1588   free(value);
1589
1590
1591   return 0;
1592 }
1593
1594 uint8_t user_supplied_bug9(memcached_st *memc)
1595 {
1596   memcached_return rc;
1597   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1598   size_t key_length[3];
1599   unsigned int x;
1600   uint32_t flags;
1601   unsigned count= 0;
1602
1603   char return_key[MEMCACHED_MAX_KEY];
1604   size_t return_key_length;
1605   char *return_value;
1606   size_t return_value_length;
1607
1608
1609   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1610   key_length[1]= strlen("fudge&*@#");
1611   key_length[2]= strlen("for^#@&$not");
1612
1613
1614   for (x= 0; x < 3; x++)
1615   {
1616     rc= memcached_set(memc, keys[x], key_length[x],
1617                       keys[x], key_length[x],
1618                       (time_t)50, (uint32_t)9);
1619     assert(rc == MEMCACHED_SUCCESS);
1620   }
1621
1622   rc= memcached_mget(memc, keys, key_length, 3);
1623   assert(rc == MEMCACHED_SUCCESS);
1624
1625   /* We need to empty the server before continueing test */
1626   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1627                       &return_value_length, &flags, &rc)) != NULL)
1628   {
1629     assert(return_value);
1630     free(return_value);
1631     count++;
1632   }
1633   assert(count == 3);
1634
1635   return 0;
1636 }
1637
1638 /* We are testing with aggressive timeout to get failures */
1639 uint8_t user_supplied_bug10(memcached_st *memc)
1640 {
1641   char *key= "foo";
1642   char *value;
1643   size_t value_length= 512;
1644   unsigned int x;
1645   int key_len= 3;
1646   memcached_return rc;
1647   unsigned int set= 1;
1648   memcached_st *mclone= memcached_clone(NULL, memc);
1649   int32_t timeout;
1650
1651   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1652   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1653   timeout= 2;
1654   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1655
1656   value = (char*)malloc(value_length * sizeof(char));
1657
1658   for (x= 0; x < value_length; x++)
1659     value[x]= (char) (x % 127);
1660
1661   for (x= 1; x <= 100000; ++x)
1662   {
1663     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1664
1665     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_BUFFERED);
1666
1667     if (rc == MEMCACHED_WRITE_FAILURE)
1668       x--;
1669   }
1670
1671   free(value);
1672   memcached_free(mclone);
1673
1674   return 0;
1675 }
1676
1677 /*
1678   We are looking failures in the async protocol
1679 */
1680 uint8_t user_supplied_bug11(memcached_st *memc)
1681 {
1682   char *key= "foo";
1683   char *value;
1684   size_t value_length= 512;
1685   unsigned int x;
1686   int key_len= 3;
1687   memcached_return rc;
1688   unsigned int set= 1;
1689   int32_t timeout;
1690   memcached_st *mclone= memcached_clone(NULL, memc);
1691
1692   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, &set);
1693   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, &set);
1694   timeout= -1;
1695   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
1696
1697   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
1698
1699   assert(timeout == -1);
1700
1701   value = (char*)malloc(value_length * sizeof(char));
1702
1703   for (x= 0; x < value_length; x++)
1704     value[x]= (char) (x % 127);
1705
1706   for (x= 1; x <= 100000; ++x)
1707   {
1708     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
1709   }
1710
1711   free(value);
1712   memcached_free(mclone);
1713
1714   return 0;
1715 }
1716
1717 /*
1718   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
1719 */
1720 uint8_t user_supplied_bug12(memcached_st *memc)
1721 {
1722   memcached_return rc;
1723   uint32_t flags;
1724   size_t value_length;
1725   char *value;
1726   uint64_t number_value;
1727
1728   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1729                         &value_length, &flags, &rc);
1730   assert(value == NULL);
1731   assert(rc == MEMCACHED_NOTFOUND);
1732
1733   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1734                           1, &number_value);
1735
1736   assert(value == NULL);
1737   assert(rc == MEMCACHED_NOTFOUND);
1738
1739   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
1740
1741   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
1742                         &value_length, &flags, &rc);
1743   assert(value);
1744   assert(rc == MEMCACHED_SUCCESS);
1745   free(value);
1746
1747   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
1748                           1, &number_value);
1749   assert(number_value == 2);
1750   assert(rc == MEMCACHED_SUCCESS);
1751
1752   return 0;
1753 }
1754
1755 /*
1756   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1757   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
1758  */
1759 uint8_t user_supplied_bug13(memcached_st *memc)
1760 {
1761   char key[] = "key34567890";
1762   char *overflow;
1763   memcached_return rc;
1764   size_t overflowSize;
1765
1766   char commandFirst[]= "set key34567890 0 0 ";
1767   char commandLast[] = " \r\n"; /* first line of command sent to server */
1768   size_t commandLength;
1769   size_t testSize;
1770
1771   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
1772
1773   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
1774
1775   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
1776   {
1777     overflow= malloc(testSize);
1778     assert(overflow != NULL);
1779
1780     memset(overflow, 'x', testSize);
1781     rc= memcached_set(memc, key, strlen(key),
1782                       overflow, testSize, 0, 0);
1783     assert(rc == MEMCACHED_SUCCESS);
1784     free(overflow);
1785   }
1786
1787   return 0;
1788 }
1789
1790
1791 /*
1792   Test values of many different sizes
1793   Bug found where command total one more than MEMCACHED_MAX_BUFFER
1794   set key34567890 0 0 8169 \r\n
1795   is sent followed by buffer of size 8169, followed by 8169
1796  */
1797 uint8_t user_supplied_bug14(memcached_st *memc)
1798 {
1799   int setter= 1;
1800   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, &setter);
1801   memcached_return rc;
1802   char *key= "foo";
1803   char *value;
1804   size_t value_length= 18000;
1805   char *string;
1806   size_t string_length;
1807   uint32_t flags;
1808   unsigned int x;
1809   size_t current_length;
1810
1811   value = (char*)malloc(value_length);
1812   assert(value);
1813
1814   for (x= 0; x < value_length; x++)
1815     value[x] = (char) (x % 127);
1816
1817   for (current_length= 1; current_length < value_length; current_length++)
1818   {
1819     rc= memcached_set(memc, key, strlen(key),
1820                       value, current_length,
1821                       (time_t)0, (uint32_t)0);
1822     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1823
1824     string= memcached_get(memc, key, strlen(key),
1825                           &string_length, &flags, &rc);
1826
1827     assert(rc == MEMCACHED_SUCCESS);
1828     assert(string);
1829     assert(string_length == current_length);
1830     assert(!memcmp(string, value, string_length));
1831
1832     free(string);
1833   }
1834
1835   free(value);
1836
1837   return 0;
1838 }
1839
1840 uint8_t result_static(memcached_st *memc)
1841 {
1842   memcached_result_st result;
1843   memcached_result_st *result_ptr;
1844
1845   result_ptr= memcached_result_create(memc, &result);
1846   assert(result.is_allocated == MEMCACHED_NOT_ALLOCATED);
1847   assert(result_ptr);
1848   memcached_result_free(&result);
1849
1850   return 0;
1851 }
1852
1853 uint8_t result_alloc(memcached_st *memc)
1854 {
1855   memcached_result_st *result;
1856
1857   result= memcached_result_create(memc, NULL);
1858   assert(result);
1859   memcached_result_free(result);
1860
1861   return 0;
1862 }
1863
1864 uint8_t string_static_null(memcached_st *memc)
1865 {
1866   memcached_string_st string;
1867   memcached_string_st *string_ptr;
1868
1869   string_ptr= memcached_string_create(memc, &string, 0);
1870   assert(string.is_allocated == MEMCACHED_NOT_ALLOCATED);
1871   assert(string_ptr);
1872   memcached_string_free(&string);
1873
1874   return 0;
1875 }
1876
1877 uint8_t string_alloc_null(memcached_st *memc)
1878 {
1879   memcached_string_st *string;
1880
1881   string= memcached_string_create(memc, NULL, 0);
1882   assert(string);
1883   memcached_string_free(string);
1884
1885   return 0;
1886 }
1887
1888 uint8_t string_alloc_with_size(memcached_st *memc)
1889 {
1890   memcached_string_st *string;
1891
1892   string= memcached_string_create(memc, NULL, 1024);
1893   assert(string);
1894   memcached_string_free(string);
1895
1896   return 0;
1897 }
1898
1899 uint8_t string_alloc_with_size_toobig(memcached_st *memc)
1900 {
1901   memcached_string_st *string;
1902
1903   string= memcached_string_create(memc, NULL, INT64_MAX);
1904   assert(string == NULL);
1905
1906   return 0;
1907 }
1908
1909 uint8_t string_alloc_append(memcached_st *memc)
1910 {
1911   unsigned int x;
1912   char buffer[SMALL_STRING_LEN];
1913   memcached_string_st *string;
1914
1915   /* Ring the bell! */
1916   memset(buffer, 6, SMALL_STRING_LEN);
1917
1918   string= memcached_string_create(memc, NULL, 100);
1919   assert(string);
1920
1921   for (x= 0; x < 1024; x++)
1922   {
1923     memcached_return rc;
1924     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1925     assert(rc == MEMCACHED_SUCCESS);
1926   }
1927   memcached_string_free(string);
1928
1929   return 0;
1930 }
1931
1932 uint8_t string_alloc_append_toobig(memcached_st *memc)
1933 {
1934   memcached_return rc;
1935   unsigned int x;
1936   char buffer[SMALL_STRING_LEN];
1937   memcached_string_st *string;
1938
1939   /* Ring the bell! */
1940   memset(buffer, 6, SMALL_STRING_LEN);
1941
1942   string= memcached_string_create(memc, NULL, 100);
1943   assert(string);
1944
1945   for (x= 0; x < 1024; x++)
1946   {
1947     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
1948     assert(rc == MEMCACHED_SUCCESS);
1949   }
1950   rc= memcached_string_append(string, buffer, INT64_MAX);
1951   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
1952   memcached_string_free(string);
1953
1954   return 0;
1955 }
1956
1957 uint8_t cleanup_pairs(memcached_st *memc)
1958 {
1959   pairs_free(global_pairs);
1960
1961   return 0;
1962 }
1963
1964 uint8_t generate_pairs(memcached_st *memc)
1965 {
1966   unsigned long long x;
1967   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
1968   global_count= GLOBAL_COUNT;
1969
1970   for (x= 0; x < global_count; x++)
1971   {
1972     global_keys[x]= global_pairs[x].key;
1973     global_keys_length[x]=  global_pairs[x].key_length;
1974   }
1975
1976   return 0;
1977 }
1978
1979 uint8_t generate_large_pairs(memcached_st *memc)
1980 {
1981   unsigned long long x;
1982   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
1983   global_count= GLOBAL2_COUNT;
1984
1985   for (x= 0; x < global_count; x++)
1986   {
1987     global_keys[x]= global_pairs[x].key;
1988     global_keys_length[x]=  global_pairs[x].key_length;
1989   }
1990
1991   return 0;
1992 }
1993
1994 uint8_t generate_data(memcached_st *memc)
1995 {
1996   execute_set(memc, global_pairs, global_count);
1997
1998   return 0;
1999 }
2000
2001 uint8_t generate_buffer_data(memcached_st *memc)
2002 {
2003   int latch= 0;
2004
2005   latch= 1;
2006   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch);
2007   generate_data(memc);
2008
2009   return 0;
2010 }
2011
2012 uint8_t get_read(memcached_st *memc)
2013 {
2014   unsigned int x;
2015   memcached_return rc;
2016
2017   {
2018     char *return_value;
2019     size_t return_value_length;
2020     uint32_t flags;
2021
2022     for (x= 0; x < global_count; x++)
2023     {
2024       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2025                                   &return_value_length, &flags, &rc);
2026       /*
2027       assert(return_value);
2028       assert(rc == MEMCACHED_SUCCESS);
2029     */
2030       if (rc == MEMCACHED_SUCCESS && return_value)
2031         free(return_value);
2032     }
2033   }
2034
2035   return 0;
2036 }
2037
2038 uint8_t mget_read(memcached_st *memc)
2039 {
2040   memcached_return rc;
2041
2042   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2043   assert(rc == MEMCACHED_SUCCESS);
2044   /* Turn this into a help function */
2045   {
2046     char return_key[MEMCACHED_MAX_KEY];
2047     size_t return_key_length;
2048     char *return_value;
2049     size_t return_value_length;
2050     uint32_t flags;
2051
2052     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2053                                           &return_value_length, &flags, &rc)))
2054     {
2055       assert(return_value);
2056       assert(rc == MEMCACHED_SUCCESS);
2057       free(return_value);
2058     }
2059   }
2060
2061   return 0;
2062 }
2063
2064 uint8_t mget_read_result(memcached_st *memc)
2065 {
2066   memcached_return rc;
2067
2068   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2069   assert(rc == MEMCACHED_SUCCESS);
2070   /* Turn this into a help function */
2071   {
2072     memcached_result_st results_obj;
2073     memcached_result_st *results;
2074
2075     results= memcached_result_create(memc, &results_obj);
2076
2077     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2078     {
2079       assert(results);
2080       assert(rc == MEMCACHED_SUCCESS);
2081     }
2082
2083     memcached_result_free(&results_obj);
2084   }
2085
2086   return 0;
2087 }
2088
2089 uint8_t mget_read_function(memcached_st *memc)
2090 {
2091   memcached_return rc;
2092   unsigned int counter;
2093   unsigned int (*callbacks[1])(memcached_st *, memcached_result_st *, void *);
2094
2095   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2096   assert(rc == MEMCACHED_SUCCESS);
2097
2098   callbacks[0]= &callback_counter;
2099   counter= 0;
2100   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2101
2102   return 0;
2103 }
2104
2105 uint8_t delete_generate(memcached_st *memc)
2106 {
2107   unsigned int x;
2108
2109   for (x= 0; x < global_count; x++)
2110   {
2111     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2112   }
2113
2114   return 0;
2115 }
2116
2117 uint8_t delete_buffer_generate(memcached_st *memc)
2118 {
2119   int latch= 0;
2120   unsigned int x;
2121
2122   latch= 1;
2123   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, &latch);
2124
2125   for (x= 0; x < global_count; x++)
2126   {
2127     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2128   }
2129
2130   return 0;
2131 }
2132
2133 uint8_t free_data(memcached_st *memc)
2134 {
2135   pairs_free(global_pairs);
2136
2137   return 0;
2138 }
2139
2140 uint8_t add_host_test1(memcached_st *memc)
2141 {
2142   unsigned int x;
2143   memcached_return rc;
2144   char servername[]= "0.example.com";
2145   memcached_server_st *servers;
2146
2147   servers= memcached_server_list_append(NULL, servername, 400, &rc);
2148   assert(servers);
2149   assert(1 == memcached_server_list_count(servers));
2150
2151   for (x= 2; x < 20; x++)
2152   {
2153     char buffer[SMALL_STRING_LEN];
2154
2155     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2156     servers= memcached_server_list_append(servers, buffer, 401,
2157                                      &rc);
2158     assert(rc == MEMCACHED_SUCCESS);
2159     assert(x == memcached_server_list_count(servers));
2160   }
2161
2162   rc= memcached_server_push(memc, servers);
2163   assert(rc == MEMCACHED_SUCCESS);
2164   rc= memcached_server_push(memc, servers);
2165   assert(rc == MEMCACHED_SUCCESS);
2166
2167   memcached_server_list_free(servers);
2168
2169   return 0;
2170 }
2171
2172 memcached_return pre_nonblock(memcached_st *memc)
2173 {
2174   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
2175
2176   return MEMCACHED_SUCCESS;
2177 }
2178
2179 memcached_return pre_md5(memcached_st *memc)
2180 {
2181   memcached_hash value= MEMCACHED_HASH_MD5;
2182   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2183
2184   return MEMCACHED_SUCCESS;
2185 }
2186
2187 memcached_return pre_crc(memcached_st *memc)
2188 {
2189   memcached_hash value= MEMCACHED_HASH_CRC;
2190   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2191
2192   return MEMCACHED_SUCCESS;
2193 }
2194
2195 memcached_return pre_hsieh(memcached_st *memc)
2196 {
2197   memcached_hash value= MEMCACHED_HASH_HSIEH;
2198   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2199
2200   return MEMCACHED_SUCCESS;
2201 }
2202
2203 memcached_return pre_hash_fnv1_64(memcached_st *memc)
2204 {
2205   memcached_hash value= MEMCACHED_HASH_FNV1_64;
2206   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2207
2208   return MEMCACHED_SUCCESS;
2209 }
2210
2211 memcached_return pre_hash_fnv1a_64(memcached_st *memc)
2212 {
2213   memcached_hash value= MEMCACHED_HASH_FNV1A_64;
2214   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2215
2216   return MEMCACHED_SUCCESS;
2217 }
2218
2219 memcached_return pre_hash_fnv1_32(memcached_st *memc)
2220 {
2221   memcached_hash value= MEMCACHED_HASH_FNV1_32;
2222   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2223
2224   return MEMCACHED_SUCCESS;
2225 }
2226
2227 memcached_return pre_hash_fnv1a_32(memcached_st *memc)
2228 {
2229   memcached_hash value= MEMCACHED_HASH_FNV1A_32;
2230   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2231
2232   return MEMCACHED_SUCCESS;
2233 }
2234
2235 memcached_return pre_hash_ketama(memcached_st *memc)
2236 {
2237   memcached_hash value= MEMCACHED_HASH_KETAMA;
2238   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, &value);
2239
2240   return MEMCACHED_SUCCESS;
2241 }
2242
2243 void my_free(memcached_st *ptr, void *mem)
2244 {
2245   free(mem);
2246 }
2247
2248 void *my_malloc(memcached_st *ptr, const size_t size)
2249 {
2250   return malloc(size);
2251 }
2252
2253 void *my_realloc(memcached_st *ptr, void *mem, const size_t size)
2254 {
2255   return realloc(mem, size);
2256 }
2257
2258 memcached_return set_memory_alloc(memcached_st *memc)
2259 {
2260   {
2261     memcached_malloc_function test_ptr;
2262     memcached_return rc;
2263
2264     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &my_malloc);
2265     assert(rc == MEMCACHED_SUCCESS);
2266     test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
2267     assert(rc == MEMCACHED_SUCCESS);
2268     assert(test_ptr == my_malloc);
2269   }
2270
2271   {
2272     memcached_realloc_function test_ptr;
2273     memcached_return rc;
2274
2275     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &my_realloc);
2276     assert(rc == MEMCACHED_SUCCESS);
2277     test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
2278     assert(rc == MEMCACHED_SUCCESS);
2279     assert(test_ptr == my_realloc);
2280   }
2281
2282   {
2283     memcached_free_function test_ptr;
2284     memcached_return rc;
2285
2286     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, my_free);
2287     assert(rc == MEMCACHED_SUCCESS);
2288     test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
2289     assert(rc == MEMCACHED_SUCCESS);
2290     assert(test_ptr == my_free);
2291   }
2292
2293   return MEMCACHED_SUCCESS;
2294 }
2295
2296 memcached_return enable_consistent(memcached_st *memc)
2297 {
2298   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
2299   memcached_hash hash;
2300   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, &value);
2301   pre_hsieh(memc);
2302
2303   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
2304   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
2305
2306   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
2307   assert(hash == MEMCACHED_HASH_HSIEH);
2308
2309
2310   return MEMCACHED_SUCCESS;
2311 }
2312
2313 memcached_return enable_cas(memcached_st *memc)
2314 {
2315   unsigned int set= 1;
2316
2317   memcached_version(memc);
2318
2319   if (memc->hosts[0].major_version >= 1 &&
2320       memc->hosts[0].minor_version >= 2 &&
2321       memc->hosts[0].micro_version >= 4)
2322   {
2323     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, &set);
2324
2325     return MEMCACHED_SUCCESS;
2326   }
2327
2328   return MEMCACHED_FAILURE;
2329 }
2330
2331 memcached_return check_for_1_2_3(memcached_st *memc)
2332 {
2333   memcached_version(memc);
2334
2335   if (memc->hosts[0].major_version >= 1 &&
2336       memc->hosts[0].minor_version >= 2 &&
2337       memc->hosts[0].micro_version >= 4)
2338     return MEMCACHED_SUCCESS;
2339
2340   return MEMCACHED_FAILURE;
2341 }
2342
2343 memcached_return pre_unix_socket(memcached_st *memc)
2344 {
2345   memcached_return rc;
2346   struct stat buf;
2347
2348   memcached_server_list_free(memc->hosts);
2349   memc->hosts= NULL;
2350   memc->number_of_hosts= 0;
2351
2352   if (stat("/tmp/memcached.socket", &buf))
2353     return MEMCACHED_FAILURE;
2354
2355   rc= memcached_server_add_unix_socket(memc, "/tmp/memcached.socket");
2356
2357   return rc;
2358 }
2359
2360 memcached_return pre_udp(memcached_st *memc)
2361 {
2362   memcached_return rc;
2363
2364   memcached_server_list_free(memc->hosts);
2365   memc->hosts= NULL;
2366   memc->number_of_hosts= 0;
2367
2368   if (0)
2369     return MEMCACHED_FAILURE;
2370
2371   rc= memcached_server_add_udp(memc, "localhost", MEMCACHED_DEFAULT_PORT);
2372
2373   return rc;
2374 }
2375
2376 memcached_return pre_nodelay(memcached_st *memc)
2377 {
2378   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, NULL);
2379   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, NULL);
2380
2381   return MEMCACHED_SUCCESS;
2382 }
2383
2384 memcached_return poll_timeout(memcached_st *memc)
2385 {
2386   int32_t timeout;
2387
2388   timeout= 100;
2389
2390   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, &timeout);
2391
2392   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2393
2394   assert(timeout == 100);
2395
2396   return MEMCACHED_SUCCESS;
2397 }
2398
2399
2400 /* Clean the server before beginning testing */
2401 test_st tests[] ={
2402   {"flush", 0, flush_test },
2403   {"init", 0, init_test },
2404   {"allocation", 0, allocation_test },
2405   {"server_list_null_test", 0, server_list_null_test},
2406   {"server_sort", 0, server_sort_test},
2407   {"clone_test", 0, clone_test },
2408   {"error", 0, error_test },
2409   {"set", 0, set_test },
2410   {"set2", 0, set_test2 },
2411   {"set3", 0, set_test3 },
2412   {"add", 1, add_test },
2413   {"replace", 1, replace_test },
2414   {"delete", 1, delete_test },
2415   {"get", 1, get_test },
2416   {"get2", 0, get_test2 },
2417   {"get3", 0, get_test3 },
2418   {"get4", 0, get_test4 },
2419   {"stats_servername", 0, stats_servername_test },
2420   {"increment", 0, increment_test },
2421   {"decrement", 0, decrement_test },
2422   {"quit", 0, quit_test },
2423   {"mget", 1, mget_test },
2424   {"mget_result", 1, mget_result_test },
2425   {"mget_result_alloc", 1, mget_result_alloc_test },
2426   {"mget_result_function", 1, mget_result_function },
2427   {"get_stats", 0, get_stats },
2428   {"add_host_test", 0, add_host_test },
2429   {"get_stats_keys", 0, get_stats_keys },
2430   {"behavior_test", 0, get_stats_keys },
2431   {"callback_test", 0, get_stats_keys },
2432   {"version_string_test", 0, version_string_test},
2433   {"bad_key", 1, bad_key_test },
2434   {"memcached_server_cursor", 1, memcached_server_cursor_test },
2435   {0, 0, 0}
2436 };
2437
2438 test_st async_tests[] ={
2439   {"add", 1, add_wrapper },
2440   {0, 0, 0}
2441 };
2442
2443 test_st string_tests[] ={
2444   {"string static with null", 0, string_static_null },
2445   {"string alloc with null", 0, string_alloc_null },
2446   {"string alloc with 1K", 0, string_alloc_with_size },
2447   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
2448   {"string append", 0, string_alloc_append },
2449   {"string append failure (too big)", 0, string_alloc_append_toobig },
2450   {0, 0, 0}
2451 };
2452
2453 test_st result_tests[] ={
2454   {"result static", 0, result_static},
2455   {"result alloc", 0, result_alloc},
2456   {0, 0, 0}
2457 };
2458
2459 test_st version_1_2_3[] ={
2460   {"append", 0, append_test },
2461   {"prepend", 0, prepend_test },
2462   {"cas", 0, cas_test },
2463   {"cas2", 0, cas2_test },
2464   {"append_binary", 0, append_binary_test },
2465   {0, 0, 0}
2466 };
2467
2468 test_st user_tests[] ={
2469   {"user_supplied_bug1", 0, user_supplied_bug1 },
2470   {"user_supplied_bug2", 0, user_supplied_bug2 },
2471   {"user_supplied_bug3", 0, user_supplied_bug3 },
2472   {"user_supplied_bug4", 0, user_supplied_bug4 },
2473   {"user_supplied_bug5", 1, user_supplied_bug5 },
2474   {"user_supplied_bug6", 1, user_supplied_bug6 },
2475   {"user_supplied_bug7", 1, user_supplied_bug7 },
2476   {"user_supplied_bug8", 1, user_supplied_bug8 },
2477   {"user_supplied_bug9", 1, user_supplied_bug9 },
2478   {"user_supplied_bug10", 1, user_supplied_bug10 },
2479   {"user_supplied_bug11", 1, user_supplied_bug11 },
2480   {"user_supplied_bug12", 1, user_supplied_bug12 },
2481   {"user_supplied_bug13", 1, user_supplied_bug13 },
2482   {"user_supplied_bug14", 1, user_supplied_bug14 },
2483   {0, 0, 0}
2484 };
2485
2486 test_st generate_tests[] ={
2487   {"generate_pairs", 1, generate_pairs },
2488   {"generate_data", 1, generate_data },
2489   {"get_read", 0, get_read },
2490   {"delete_generate", 0, delete_generate },
2491   {"generate_buffer_data", 1, generate_buffer_data },
2492   {"delete_buffer", 0, delete_buffer_generate},
2493   {"generate_data", 1, generate_data },
2494   {"mget_read", 0, mget_read },
2495   {"mget_read_result", 0, mget_read_result },
2496   {"mget_read_function", 0, mget_read_function },
2497   {"cleanup", 1, cleanup_pairs },
2498   {"generate_large_pairs", 1, generate_large_pairs },
2499   {"generate_data", 1, generate_data },
2500   {"generate_buffer_data", 1, generate_buffer_data },
2501   {"cleanup", 1, cleanup_pairs },
2502   {0, 0, 0}
2503 };
2504
2505
2506 collection_st collection[] ={
2507   {"block", 0, 0, tests},
2508   {"nonblock", pre_nonblock, 0, tests},
2509   {"nodelay", pre_nodelay, 0, tests},
2510   {"md5", pre_md5, 0, tests},
2511   {"crc", pre_crc, 0, tests},
2512   {"hsieh", pre_hsieh, 0, tests},
2513   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
2514   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
2515   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
2516   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
2517   {"ketama", pre_hash_ketama, 0, tests},
2518   {"unix_socket", pre_unix_socket, 0, tests},
2519   {"unix_socket_nodelay", pre_nodelay, 0, tests},
2520   {"poll_timeout", poll_timeout, 0, tests},
2521   {"gets", enable_cas, 0, tests},
2522   {"consistent", enable_consistent, 0, tests},
2523   {"memory_allocators", set_memory_alloc, 0, tests},
2524 //  {"udp", pre_udp, 0, tests},
2525   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
2526   {"string", 0, 0, string_tests},
2527   {"result", 0, 0, result_tests},
2528   {"async", pre_nonblock, 0, async_tests},
2529   {"user", 0, 0, user_tests},
2530   {"generate", 0, 0, generate_tests},
2531   {"generate_hsieh", pre_hsieh, 0, generate_tests},
2532   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
2533   {"generate_md5", pre_md5, 0, generate_tests},
2534   {"generate_nonblock", pre_nonblock, 0, generate_tests},
2535   {0, 0, 0, 0}
2536 };
2537
2538 #define SERVERS_TO_CREATE 5
2539
2540 void *world_create(void)
2541 {
2542   server_startup_st *construct;
2543
2544   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
2545   memset(construct, 0, sizeof(server_startup_st));
2546   construct->count= SERVERS_TO_CREATE;
2547   construct->udp= 0;
2548   server_startup(construct);
2549
2550   return construct;
2551 }
2552
2553 void world_destroy(void *p)
2554 {
2555   server_startup_st *construct= (server_startup_st *)p;
2556   memcached_server_st *servers= (memcached_server_st *)construct->servers;
2557   memcached_server_list_free(servers);
2558
2559   server_shutdown(construct);
2560   free(construct);
2561 }
2562
2563 void get_world(world_st *world)
2564 {
2565   world->collections= collection;
2566   world->create= world_create;
2567   world->destroy= world_destroy;
2568 }