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