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