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