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