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

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