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