git.m6w6.name Git - m6w6/libmemcached/blob - tests/function.c

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