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

   1 /*
   2   Sample test application.
   3 */
   4 #include <assert.h>
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <string.h>
   8 #include <sys/time.h>
   9 #include <sys/types.h>
  10 #include <sys/stat.h>
  11 #include <unistd.h>
  12 #include <time.h>
  13 #include "server.h"
  14 #include "../clients/generator.h"
  15 #include "../clients/execute.h"
  16
  17 #ifndef INT64_MAX
  18 #define INT64_MAX LONG_MAX
  19 #endif
  20 #ifndef INT32_MAX
  21 #define INT32_MAX INT_MAX
  22 #endif
  23
  24
  25 #include "test.h"
  26
  27 #define GLOBAL_COUNT 10000
  28 #define GLOBAL2_COUNT 100
  29 #define SERVERS_TO_CREATE 5
  30 static uint32_t global_count;
  31
  32 static pairs_st *global_pairs;
  33 static char *global_keys[GLOBAL_COUNT];
  34 static size_t global_keys_length[GLOBAL_COUNT];
  35
  36 static test_return  init_test(memcached_st *not_used __attribute__((unused)))
  37 {
  38   memcached_st memc;
  39
  40   (void)memcached_create(&memc);
  41   memcached_free(&memc);
  42
  43   return 0;
  44 }
  45
  46 static test_return  server_list_null_test(memcached_st *ptr __attribute__((unused)))
  47 {
  48   memcached_server_st *server_list;
  49   memcached_return rc;
  50
  51   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
  52   assert(server_list == NULL);
  53
  54   server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
  55   assert(server_list == NULL);
  56
  57   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
  58   assert(server_list == NULL);
  59
  60   return 0;
  61 }
  62
  63 #define TEST_PORT_COUNT 7
  64 uint32_t test_ports[TEST_PORT_COUNT];
  65
  66 static memcached_return  server_display_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
  67 {
  68   /* Do Nothing */
  69   uint32_t bigger= *((uint32_t *)(context));
  70   assert(bigger <= server->port);
  71   *((uint32_t *)(context))= server->port;
  72
  73   return MEMCACHED_SUCCESS;
  74 }
  75
  76 static test_return  server_sort_test(memcached_st *ptr __attribute__((unused)))
  77 {
  78   uint32_t x;
  79   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
  80   memcached_return rc;
  81   memcached_server_function callbacks[1];
  82   memcached_st *local_memc;
  83
  84   local_memc= memcached_create(NULL);
  85   assert(local_memc);
  86   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
  87
  88   for (x= 0; x < TEST_PORT_COUNT; x++)
  89   {
  90     test_ports[x]= random() % 64000;
  91     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
  92     assert(local_memc->number_of_hosts == x + 1);
  93     assert(local_memc->hosts[0].count == x+1);
  94     assert(rc == MEMCACHED_SUCCESS);
  95   }
  96
  97   callbacks[0]= server_display_function;
  98   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
  99
 100
 101   memcached_free(local_memc);
 102
 103   return 0;
 104 }
 105
 106 static test_return  server_sort2_test(memcached_st *ptr __attribute__((unused)))
 107 {
 108   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
 109   memcached_return rc;
 110   memcached_server_function callbacks[1];
 111   memcached_st *local_memc;
 112
 113   local_memc= memcached_create(NULL);
 114   assert(local_memc);
 115   rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 116   assert(rc == MEMCACHED_SUCCESS);
 117
 118   rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
 119   assert(rc == MEMCACHED_SUCCESS);
 120   assert(local_memc->hosts[0].port == 43043);
 121
 122   rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
 123   assert(rc == MEMCACHED_SUCCESS);
 124   assert(local_memc->hosts[0].port == 43042);
 125   assert(local_memc->hosts[1].port == 43043);
 126
 127   callbacks[0]= server_display_function;
 128   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 129
 130
 131   memcached_free(local_memc);
 132
 133   return 0;
 134 }
 135
 136 static memcached_return  server_display_unsort_function(memcached_st *ptr __attribute__((unused)), memcached_server_st *server, void *context)
 137 {
 138   /* Do Nothing */
 139   uint32_t x= *((uint32_t *)(context));
 140
 141   assert(test_ports[x] == server->port);
 142   *((uint32_t *)(context))= ++x;
 143
 144   return MEMCACHED_SUCCESS;
 145 }
 146
 147 static test_return  server_unsort_test(memcached_st *ptr __attribute__((unused)))
 148 {
 149   uint32_t x;
 150   uint32_t counter= 0; /* Prime the value for the assert in server_display_function */
 151   uint32_t bigger= 0; /* Prime the value for the assert in server_display_function */
 152   memcached_return rc;
 153   memcached_server_function callbacks[1];
 154   memcached_st *local_memc;
 155
 156   local_memc= memcached_create(NULL);
 157   assert(local_memc);
 158
 159   for (x= 0; x < TEST_PORT_COUNT; x++)
 160   {
 161     test_ports[x]= random() % 64000;
 162     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
 163     assert(local_memc->number_of_hosts == x+1);
 164     assert(local_memc->hosts[0].count == x+1);
 165     assert(rc == MEMCACHED_SUCCESS);
 166   }
 167
 168   callbacks[0]= server_display_unsort_function;
 169   memcached_server_cursor(local_memc, callbacks, (void *)&counter,  1);
 170
 171   /* Now we sort old data! */
 172   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 173   callbacks[0]= server_display_function;
 174   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 175
 176
 177   memcached_free(local_memc);
 178
 179   return 0;
 180 }
 181
 182 static test_return  allocation_test(memcached_st *not_used __attribute__((unused)))
 183 {
 184   memcached_st *memc;
 185   memc= memcached_create(NULL);
 186   assert(memc);
 187   memcached_free(memc);
 188
 189   return 0;
 190 }
 191
 192 static test_return  clone_test(memcached_st *memc)
 193 {
 194   /* All null? */
 195   {
 196     memcached_st *clone;
 197     clone= memcached_clone(NULL, NULL);
 198     assert(clone);
 199     memcached_free(clone);
 200   }
 201
 202   /* Can we init from null? */
 203   {
 204     memcached_st *clone;
 205     clone= memcached_clone(NULL, memc);
 206     assert(clone);
 207
 208     assert(clone->call_free == memc->call_free);
 209     assert(clone->call_malloc == memc->call_malloc);
 210     assert(clone->call_realloc == memc->call_realloc);
 211     assert(clone->connect_timeout == memc->connect_timeout);
 212     assert(clone->delete_trigger == memc->delete_trigger);
 213     assert(clone->distribution == memc->distribution);
 214     assert(clone->flags == memc->flags);
 215     assert(clone->get_key_failure == memc->get_key_failure);
 216     assert(clone->hash == memc->hash);
 217     assert(clone->hash_continuum == memc->hash_continuum);
 218     assert(clone->io_bytes_watermark == memc->io_bytes_watermark);
 219     assert(clone->io_msg_watermark == memc->io_msg_watermark);
 220     assert(clone->on_cleanup == memc->on_cleanup);
 221     assert(clone->on_clone == memc->on_clone);
 222     assert(clone->poll_timeout == memc->poll_timeout);
 223     assert(clone->rcv_timeout == memc->rcv_timeout);
 224     assert(clone->recv_size == memc->recv_size);
 225     assert(clone->retry_timeout == memc->retry_timeout);
 226     assert(clone->send_size == memc->send_size);
 227     assert(clone->server_failure_limit == memc->server_failure_limit);
 228     assert(clone->snd_timeout == memc->snd_timeout);
 229     assert(clone->user_data == memc->user_data);
 230
 231     memcached_free(clone);
 232   }
 233
 234   /* Can we init from struct? */
 235   {
 236     memcached_st declared_clone;
 237     memcached_st *clone;
 238     memset(&declared_clone, 0 , sizeof(memcached_st));
 239     clone= memcached_clone(&declared_clone, NULL);
 240     assert(clone);
 241     memcached_free(clone);
 242   }
 243
 244   /* Can we init from struct? */
 245   {
 246     memcached_st declared_clone;
 247     memcached_st *clone;
 248     memset(&declared_clone, 0 , sizeof(memcached_st));
 249     clone= memcached_clone(&declared_clone, memc);
 250     assert(clone);
 251     memcached_free(clone);
 252   }
 253
 254   return 0;
 255 }
 256
 257 static test_return  connection_test(memcached_st *memc)
 258 {
 259   memcached_return rc;
 260
 261   rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
 262   assert(rc == MEMCACHED_SUCCESS);
 263
 264   return 0;
 265 }
 266
 267 static test_return  error_test(memcached_st *memc)
 268 {
 269   memcached_return rc;
 270
 271   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 272   {
 273     printf("Error %d -> %s\n", rc, memcached_strerror(memc, rc));
 274   }
 275
 276   return 0;
 277 }
 278
 279 static test_return  set_test(memcached_st *memc)
 280 {
 281   memcached_return rc;
 282   char *key= "foo";
 283   char *value= "when we sanitize";
 284
 285   rc= memcached_set(memc, key, strlen(key),
 286                     value, strlen(value),
 287                     (time_t)0, (uint32_t)0);
 288   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 289
 290   return 0;
 291 }
 292
 293 static test_return  append_test(memcached_st *memc)
 294 {
 295   memcached_return rc;
 296   char *key= "fig";
 297   char *value= "we";
 298   size_t value_length;
 299   uint32_t flags;
 300
 301   rc= memcached_flush(memc, 0);
 302   assert(rc == MEMCACHED_SUCCESS);
 303
 304   rc= memcached_set(memc, key, strlen(key),
 305                     value, strlen(value),
 306                     (time_t)0, (uint32_t)0);
 307   assert(rc == MEMCACHED_SUCCESS);
 308
 309   rc= memcached_append(memc, key, strlen(key),
 310                        " the", strlen(" the"),
 311                        (time_t)0, (uint32_t)0);
 312   assert(rc == MEMCACHED_SUCCESS);
 313
 314   rc= memcached_append(memc, key, strlen(key),
 315                        " people", strlen(" people"),
 316                        (time_t)0, (uint32_t)0);
 317   assert(rc == MEMCACHED_SUCCESS);
 318
 319   value= memcached_get(memc, key, strlen(key),
 320                        &value_length, &flags, &rc);
 321   assert(!memcmp(value, "we the people", strlen("we the people")));
 322   assert(strlen("we the people") == value_length);
 323   assert(rc == MEMCACHED_SUCCESS);
 324   free(value);
 325
 326   return 0;
 327 }
 328
 329 static test_return  append_binary_test(memcached_st *memc)
 330 {
 331   memcached_return rc;
 332   char *key= "numbers";
 333   unsigned int *store_ptr;
 334   unsigned int store_list[] = { 23, 56, 499, 98, 32847, 0 };
 335   char *value;
 336   size_t value_length;
 337   uint32_t flags;
 338   unsigned int x;
 339
 340   rc= memcached_flush(memc, 0);
 341   assert(rc == MEMCACHED_SUCCESS);
 342
 343   rc= memcached_set(memc,
 344                     key, strlen(key),
 345                     NULL, 0,
 346                     (time_t)0, (uint32_t)0);
 347   assert(rc == MEMCACHED_SUCCESS);
 348
 349   for (x= 0; store_list[x] ; x++)
 350   {
 351     rc= memcached_append(memc,
 352                          key, strlen(key),
 353                          (char *)&store_list[x], sizeof(unsigned int),
 354                          (time_t)0, (uint32_t)0);
 355     assert(rc == MEMCACHED_SUCCESS);
 356   }
 357
 358   value= memcached_get(memc, key, strlen(key),
 359                        &value_length, &flags, &rc);
 360   assert((value_length == (sizeof(unsigned int) * x)));
 361   assert(rc == MEMCACHED_SUCCESS);
 362
 363   store_ptr= (unsigned int *)value;
 364   x= 0;
 365   while ((size_t)store_ptr < (size_t)(value + value_length))
 366   {
 367     assert(*store_ptr == store_list[x++]);
 368     store_ptr++;
 369   }
 370   free(value);
 371
 372   return 0;
 373 }
 374
 375 static test_return  cas2_test(memcached_st *memc)
 376 {
 377   memcached_return rc;
 378   char *keys[]= {"fudge", "son", "food"};
 379   size_t key_length[]= {5, 3, 4};
 380   char *value= "we the people";
 381   size_t value_length= strlen("we the people");
 382   unsigned int x;
 383   memcached_result_st results_obj;
 384   memcached_result_st *results;
 385   unsigned int set= 1;
 386
 387   rc= memcached_flush(memc, 0);
 388   assert(rc == MEMCACHED_SUCCESS);
 389
 390   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 391
 392   for (x= 0; x < 3; x++)
 393   {
 394     rc= memcached_set(memc, keys[x], key_length[x],
 395                       keys[x], key_length[x],
 396                       (time_t)50, (uint32_t)9);
 397     assert(rc == MEMCACHED_SUCCESS);
 398   }
 399
 400   rc= memcached_mget(memc, keys, key_length, 3);
 401
 402   results= memcached_result_create(memc, &results_obj);
 403
 404   results= memcached_fetch_result(memc, &results_obj, &rc);
 405   assert(results);
 406   assert(results->cas);
 407   assert(rc == MEMCACHED_SUCCESS);
 408   WATCHPOINT_ASSERT(memcached_result_cas(results));
 409
 410   assert(!memcmp(value, "we the people", strlen("we the people")));
 411   assert(strlen("we the people") == value_length);
 412   assert(rc == MEMCACHED_SUCCESS);
 413
 414   memcached_result_free(&results_obj);
 415
 416   return 0;
 417 }
 418
 419 static test_return  cas_test(memcached_st *memc)
 420 {
 421   memcached_return rc;
 422   const char *key= "fun";
 423   size_t key_length= strlen(key);
 424   const char *value= "we the people";
 425   char* keys[2] = { (char*)key, NULL };
 426   size_t keylengths[2] = { strlen(key), 0 };
 427   size_t value_length= strlen(value);
 428   const char *value2= "change the value";
 429   size_t value2_length= strlen(value2);
 430
 431   memcached_result_st results_obj;
 432   memcached_result_st *results;
 433   unsigned int set= 1;
 434
 435   rc= memcached_flush(memc, 0);
 436   assert(rc == MEMCACHED_SUCCESS);
 437
 438   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 439
 440   rc= memcached_set(memc, key, strlen(key),
 441                     value, strlen(value),
 442                     (time_t)0, (uint32_t)0);
 443   assert(rc == MEMCACHED_SUCCESS);
 444
 445   rc= memcached_mget(memc, keys, keylengths, 1);
 446
 447   results= memcached_result_create(memc, &results_obj);
 448
 449   results= memcached_fetch_result(memc, &results_obj, &rc);
 450   assert(results);
 451   assert(rc == MEMCACHED_SUCCESS);
 452   WATCHPOINT_ASSERT(memcached_result_cas(results));
 453   assert(!memcmp(value, memcached_result_value(results), value_length));
 454   assert(strlen(memcached_result_value(results)) == value_length);
 455   assert(rc == MEMCACHED_SUCCESS);
 456   uint64_t cas = memcached_result_cas(results);
 457
 458   #if 0
 459   results= memcached_fetch_result(memc, &results_obj, &rc);
 460   assert(rc == MEMCACHED_END);
 461   assert(results == NULL);
 462 #endif
 463
 464   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
 465   assert(rc == MEMCACHED_SUCCESS);
 466
 467   /*
 468    * The item will have a new cas value, so try to set it again with the old
 469    * value. This should fail!
 470    */
 471   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
 472   assert(rc == MEMCACHED_DATA_EXISTS);
 473
 474   memcached_result_free(&results_obj);
 475
 476   return 0;
 477 }
 478
 479 static test_return  prepend_test(memcached_st *memc)
 480 {
 481   memcached_return rc;
 482   char *key= "fig";
 483   char *value= "people";
 484   size_t value_length;
 485   uint32_t flags;
 486
 487   rc= memcached_flush(memc, 0);
 488   assert(rc == MEMCACHED_SUCCESS);
 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);
 494
 495   rc= memcached_prepend(memc, key, strlen(key),
 496                        "the ", strlen("the "),
 497                        (time_t)0, (uint32_t)0);
 498   assert(rc == MEMCACHED_SUCCESS);
 499
 500   rc= memcached_prepend(memc, key, strlen(key),
 501                        "we ", strlen("we "),
 502                        (time_t)0, (uint32_t)0);
 503   assert(rc == MEMCACHED_SUCCESS);
 504
 505   value= memcached_get(memc, key, strlen(key),
 506                        &value_length, &flags, &rc);
 507   assert(!memcmp(value, "we the people", strlen("we the people")));
 508   assert(strlen("we the people") == value_length);
 509   assert(rc == MEMCACHED_SUCCESS);
 510   free(value);
 511
 512   return 0;
 513 }
 514
 515 /*
 516   Set the value, then quit to make sure it is flushed.
 517   Come back in and test that add fails.
 518 */
 519 static test_return  add_test(memcached_st *memc)
 520 {
 521   memcached_return rc;
 522   char *key= "foo";
 523   char *value= "when we sanitize";
 524   unsigned long long setting_value;
 525
 526   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 527
 528   rc= memcached_set(memc, key, strlen(key),
 529                     value, strlen(value),
 530                     (time_t)0, (uint32_t)0);
 531   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 532   memcached_quit(memc);
 533   rc= memcached_add(memc, key, strlen(key),
 534                     value, strlen(value),
 535                     (time_t)0, (uint32_t)0);
 536
 537   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 538   if (setting_value)
 539     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
 540   else
 541     assert(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
 542
 543   return 0;
 544 }
 545
 546 /*
 547 ** There was a problem of leaking filedescriptors in the initial release
 548 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
 549 ** systems it seems that the kernel is slow on reclaiming the resources
 550 ** because the connects starts to time out (the test doesn't do much
 551 ** anyway, so just loop 10 iterations)
 552 */
 553 static test_return  add_wrapper(memcached_st *memc)
 554 {
 555   unsigned int x;
 556   unsigned int max= 10000;
 557 #ifdef __sun
 558   max= 10;
 559 #endif
 560
 561   for (x= 0; x < max; x++)
 562     add_test(memc);
 563
 564   return 0;
 565 }
 566
 567 static test_return  replace_test(memcached_st *memc)
 568 {
 569   memcached_return rc;
 570   char *key= "foo";
 571   char *value= "when we sanitize";
 572   char *original= "first we insert some data";
 573
 574   rc= memcached_set(memc, key, strlen(key),
 575                     original, strlen(original),
 576                     (time_t)0, (uint32_t)0);
 577   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 578
 579   rc= memcached_replace(memc, key, strlen(key),
 580                     value, strlen(value),
 581                     (time_t)0, (uint32_t)0);
 582   assert(rc == MEMCACHED_SUCCESS);
 583
 584   return 0;
 585 }
 586
 587 static test_return  delete_test(memcached_st *memc)
 588 {
 589   memcached_return rc;
 590   char *key= "foo";
 591   char *value= "when we sanitize";
 592
 593   rc= memcached_set(memc, key, strlen(key),
 594                     value, strlen(value),
 595                     (time_t)0, (uint32_t)0);
 596   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 597
 598   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 599   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 600
 601   return 0;
 602 }
 603
 604 static test_return  flush_test(memcached_st *memc)
 605 {
 606   memcached_return rc;
 607
 608   rc= memcached_flush(memc, 0);
 609   assert(rc == MEMCACHED_SUCCESS);
 610
 611   return 0;
 612 }
 613
 614 static memcached_return  server_function(memcached_st *ptr __attribute__((unused)),
 615                                          memcached_server_st *server __attribute__((unused)),
 616                                          void *context __attribute__((unused)))
 617 {
 618   /* Do Nothing */
 619
 620   return MEMCACHED_SUCCESS;
 621 }
 622
 623 static test_return  memcached_server_cursor_test(memcached_st *memc)
 624 {
 625   char *context= "foo bad";
 626   memcached_server_function callbacks[1];
 627
 628   callbacks[0]= server_function;
 629   memcached_server_cursor(memc, callbacks, context,  1);
 630
 631   return 0;
 632 }
 633
 634 static test_return  bad_key_test(memcached_st *memc)
 635 {
 636   memcached_return rc;
 637   char *key= "foo bad";
 638   char *string;
 639   size_t string_length;
 640   uint32_t flags;
 641   memcached_st *clone;
 642   unsigned int set= 1;
 643   size_t max_keylen= 0xffff;
 644
 645   clone= memcached_clone(NULL, memc);
 646   assert(clone);
 647
 648   rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 649   assert(rc == MEMCACHED_SUCCESS);
 650
 651   /* All keys are valid in the binary protocol (except for length) */
 652   if (memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
 653   {
 654     string= memcached_get(clone, key, strlen(key),
 655                           &string_length, &flags, &rc);
 656     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 657     assert(string_length ==  0);
 658     assert(!string);
 659
 660     set= 0;
 661     rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 662     assert(rc == MEMCACHED_SUCCESS);
 663     string= memcached_get(clone, key, strlen(key),
 664                           &string_length, &flags, &rc);
 665     assert(rc == MEMCACHED_NOTFOUND);
 666     assert(string_length ==  0);
 667     assert(!string);
 668
 669     /* Test multi key for bad keys */
 670     char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
 671     size_t key_lengths[] = { 7, 7, 7 };
 672     set= 1;
 673     rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 674     assert(rc == MEMCACHED_SUCCESS);
 675
 676     rc= memcached_mget(clone, keys, key_lengths, 3);
 677     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 678
 679     rc= memcached_mget_by_key(clone, "foo daddy", 9, keys, key_lengths, 1);
 680     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 681
 682     max_keylen= 250;
 683
 684     /* The following test should be moved to the end of this function when the
 685        memcached server is updated to allow max size length of the keys in the
 686        binary protocol
 687     */
 688     rc= memcached_callback_set(clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
 689     assert(rc == MEMCACHED_SUCCESS);
 690
 691     char *longkey= malloc(max_keylen + 1);
 692     if (longkey != NULL)
 693     {
 694       memset(longkey, 'a', max_keylen + 1);
 695       string= memcached_get(clone, longkey, max_keylen,
 696                             &string_length, &flags, &rc);
 697       assert(rc == MEMCACHED_NOTFOUND);
 698       assert(string_length ==  0);
 699       assert(!string);
 700
 701       string= memcached_get(clone, longkey, max_keylen + 1,
 702                             &string_length, &flags, &rc);
 703       assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 704       assert(string_length ==  0);
 705       assert(!string);
 706
 707       free(longkey);
 708     }
 709   }
 710
 711   /* Make sure zero length keys are marked as bad */
 712   set= 1;
 713   rc= memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 714   assert(rc == MEMCACHED_SUCCESS);
 715   string= memcached_get(clone, key, 0,
 716                         &string_length, &flags, &rc);
 717   assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
 718   assert(string_length ==  0);
 719   assert(!string);
 720
 721   memcached_free(clone);
 722
 723   return 0;
 724 }
 725
 726 #define READ_THROUGH_VALUE "set for me"
 727 static memcached_return  read_through_trigger(memcached_st *memc __attribute__((unused)),
 728                                       char *key __attribute__((unused)),
 729                                       size_t key_length __attribute__((unused)),
 730                                       memcached_result_st *result)
 731 {
 732
 733   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 734 }
 735
 736 static test_return  read_through(memcached_st *memc)
 737 {
 738   memcached_return rc;
 739   char *key= "foo";
 740   char *string;
 741   size_t string_length;
 742   uint32_t flags;
 743
 744   string= memcached_get(memc, key, strlen(key),
 745                         &string_length, &flags, &rc);
 746
 747   assert(rc == MEMCACHED_NOTFOUND);
 748   assert(string_length ==  0);
 749   assert(!string);
 750
 751   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, (void *)read_through_trigger);
 752   assert(rc == MEMCACHED_SUCCESS);
 753
 754   string= memcached_get(memc, key, strlen(key),
 755                         &string_length, &flags, &rc);
 756
 757   assert(rc == MEMCACHED_SUCCESS);
 758   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 759   assert(!strcmp(READ_THROUGH_VALUE, string));
 760   free(string);
 761
 762   string= memcached_get(memc, key, strlen(key),
 763                         &string_length, &flags, &rc);
 764
 765   assert(rc == MEMCACHED_SUCCESS);
 766   assert(string_length ==  strlen(READ_THROUGH_VALUE));
 767   assert(!strcmp(READ_THROUGH_VALUE, string));
 768   free(string);
 769
 770   return 0;
 771 }
 772
 773 static memcached_return  delete_trigger(memcached_st *ptr __attribute__((unused)),
 774                                         const char *key,
 775                                         size_t key_length __attribute__((unused)))
 776 {
 777   assert(key);
 778
 779   return MEMCACHED_SUCCESS;
 780 }
 781
 782 static test_return  delete_through(memcached_st *memc)
 783 {
 784   memcached_trigger_delete_key callback;
 785   memcached_return rc;
 786
 787   callback= delete_trigger;
 788
 789   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, (void*)callback);
 790   assert(rc == MEMCACHED_SUCCESS);
 791
 792   return 0;
 793 }
 794
 795 static test_return  get_test(memcached_st *memc)
 796 {
 797   memcached_return rc;
 798   char *key= "foo";
 799   char *string;
 800   size_t string_length;
 801   uint32_t flags;
 802
 803   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 804   assert(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 805
 806   string= memcached_get(memc, key, strlen(key),
 807                         &string_length, &flags, &rc);
 808
 809   assert(rc == MEMCACHED_NOTFOUND);
 810   assert(string_length ==  0);
 811   assert(!string);
 812
 813   return 0;
 814 }
 815
 816 static test_return  get_test2(memcached_st *memc)
 817 {
 818   memcached_return rc;
 819   char *key= "foo";
 820   char *value= "when we sanitize";
 821   char *string;
 822   size_t string_length;
 823   uint32_t flags;
 824
 825   rc= memcached_set(memc, key, strlen(key),
 826                     value, strlen(value),
 827                     (time_t)0, (uint32_t)0);
 828   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 829
 830   string= memcached_get(memc, key, strlen(key),
 831                         &string_length, &flags, &rc);
 832
 833   assert(string);
 834   assert(rc == MEMCACHED_SUCCESS);
 835   assert(string_length == strlen(value));
 836   assert(!memcmp(string, value, string_length));
 837
 838   free(string);
 839
 840   return 0;
 841 }
 842
 843 static test_return  set_test2(memcached_st *memc)
 844 {
 845   memcached_return rc;
 846   char *key= "foo";
 847   char *value= "train in the brain";
 848   size_t value_length= strlen(value);
 849   unsigned int x;
 850
 851   for (x= 0; x < 10; x++)
 852   {
 853     rc= memcached_set(memc, key, strlen(key),
 854                       value, value_length,
 855                       (time_t)0, (uint32_t)0);
 856     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 857   }
 858
 859   return 0;
 860 }
 861
 862 static test_return  set_test3(memcached_st *memc)
 863 {
 864   memcached_return rc;
 865   char *key= "foo";
 866   char *value;
 867   size_t value_length= 8191;
 868   unsigned int x;
 869
 870   value = (char*)malloc(value_length);
 871   assert(value);
 872
 873   for (x= 0; x < value_length; x++)
 874     value[x] = (char) (x % 127);
 875
 876   for (x= 0; x < 1; x++)
 877   {
 878     rc= memcached_set(memc, key, strlen(key),
 879                       value, value_length,
 880                       (time_t)0, (uint32_t)0);
 881     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 882   }
 883
 884   free(value);
 885
 886   return 0;
 887 }
 888
 889 static test_return  get_test3(memcached_st *memc)
 890 {
 891   memcached_return rc;
 892   char *key= "foo";
 893   char *value;
 894   size_t value_length= 8191;
 895   char *string;
 896   size_t string_length;
 897   uint32_t flags;
 898   uint32_t x;
 899
 900   value = (char*)malloc(value_length);
 901   assert(value);
 902
 903   for (x= 0; x < value_length; x++)
 904     value[x] = (char) (x % 127);
 905
 906   rc= memcached_set(memc, key, strlen(key),
 907                     value, value_length,
 908                     (time_t)0, (uint32_t)0);
 909   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 910
 911   string= memcached_get(memc, key, strlen(key),
 912                         &string_length, &flags, &rc);
 913
 914   assert(rc == MEMCACHED_SUCCESS);
 915   assert(string);
 916   assert(string_length == value_length);
 917   assert(!memcmp(string, value, string_length));
 918
 919   free(string);
 920   free(value);
 921
 922   return 0;
 923 }
 924
 925 static test_return  get_test4(memcached_st *memc)
 926 {
 927   memcached_return rc;
 928   char *key= "foo";
 929   char *value;
 930   size_t value_length= 8191;
 931   char *string;
 932   size_t string_length;
 933   uint32_t flags;
 934   uint32_t x;
 935
 936   value = (char*)malloc(value_length);
 937   assert(value);
 938
 939   for (x= 0; x < value_length; x++)
 940     value[x] = (char) (x % 127);
 941
 942   rc= memcached_set(memc, key, strlen(key),
 943                     value, value_length,
 944                     (time_t)0, (uint32_t)0);
 945   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 946
 947   for (x= 0; x < 10; x++)
 948   {
 949     string= memcached_get(memc, key, strlen(key),
 950                           &string_length, &flags, &rc);
 951
 952     assert(rc == MEMCACHED_SUCCESS);
 953     assert(string);
 954     assert(string_length == value_length);
 955     assert(!memcmp(string, value, string_length));
 956     free(string);
 957   }
 958
 959   free(value);
 960
 961   return 0;
 962 }
 963
 964 /*
 965  * This test verifies that memcached_read_one_response doesn't try to
 966  * dereference a NIL-pointer if you issue a multi-get and don't read out all
 967  * responses before you execute a storage command.
 968  */
 969 static test_return get_test5(memcached_st *memc)
 970 {
 971   /*
 972   ** Request the same key twice, to ensure that we hash to the same server
 973   ** (so that we have multiple response values queued up) ;-)
 974   */
 975   char *keys[]= { "key", "key" };
 976   size_t lengths[]= { 3, 3 };
 977   uint32_t flags;
 978   size_t rlen;
 979
 980   memcached_return rc= memcached_set(memc, keys[0], lengths[0],
 981                                      keys[0], lengths[0], 0, 0);
 982   assert(rc == MEMCACHED_SUCCESS);
 983   rc= memcached_mget(memc, keys, lengths, 2);
 984
 985   memcached_result_st results_obj;
 986   memcached_result_st *results;
 987   results=memcached_result_create(memc, &results_obj);
 988   assert(results);
 989   results=memcached_fetch_result(memc, &results_obj, &rc);
 990   assert(results);
 991   memcached_result_free(&results_obj);
 992
 993   /* Don't read out the second result, but issue a set instead.. */
 994   rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
 995   assert(rc == MEMCACHED_SUCCESS);
 996
 997   char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
 998                                   &rlen, &flags, &rc);
 999   assert(val == NULL);
1000   assert(rc == MEMCACHED_NOTFOUND);
1001   val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
1002   assert(val != NULL);
1003   assert(rc == MEMCACHED_SUCCESS);
1004   free(val);
1005
1006   return TEST_SUCCESS;
1007 }
1008
1009 /* Do not copy the style of this code, I just access hosts to testthis function */
1010 static test_return  stats_servername_test(memcached_st *memc)
1011 {
1012   memcached_return rc;
1013   memcached_stat_st stat;
1014   rc= memcached_stat_servername(&stat, NULL,
1015                                  memc->hosts[0].hostname,
1016                                  memc->hosts[0].port);
1017
1018   return 0;
1019 }
1020
1021 static test_return  increment_test(memcached_st *memc)
1022 {
1023   uint64_t new_number;
1024   memcached_return rc;
1025   char *key= "number";
1026   char *value= "0";
1027
1028   rc= memcached_set(memc, key, strlen(key),
1029                     value, strlen(value),
1030                     (time_t)0, (uint32_t)0);
1031   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1032
1033   rc= memcached_increment(memc, key, strlen(key),
1034                           1, &new_number);
1035   assert(rc == MEMCACHED_SUCCESS);
1036   assert(new_number == 1);
1037
1038   rc= memcached_increment(memc, key, strlen(key),
1039                           1, &new_number);
1040   assert(rc == MEMCACHED_SUCCESS);
1041   assert(new_number == 2);
1042
1043   return 0;
1044 }
1045
1046 static test_return  increment_with_initial_test(memcached_st *memc)
1047 {
1048   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1049   {
1050     uint64_t new_number;
1051     memcached_return rc;
1052     char *key= "number";
1053     uint64_t initial= 0;
1054
1055     rc= memcached_increment_with_initial(memc, key, strlen(key),
1056                                          1, initial, 0, &new_number);
1057     assert(rc == MEMCACHED_SUCCESS);
1058     assert(new_number == initial);
1059
1060     rc= memcached_increment_with_initial(memc, key, strlen(key),
1061                                          1, initial, 0, &new_number);
1062     assert(rc == MEMCACHED_SUCCESS);
1063     assert(new_number == (initial + 1));
1064   }
1065   return 0;
1066 }
1067
1068 static test_return  decrement_test(memcached_st *memc)
1069 {
1070   uint64_t new_number;
1071   memcached_return rc;
1072   char *key= "number";
1073   char *value= "3";
1074
1075   rc= memcached_set(memc, key, strlen(key),
1076                     value, strlen(value),
1077                     (time_t)0, (uint32_t)0);
1078   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1079
1080   rc= memcached_decrement(memc, key, strlen(key),
1081                           1, &new_number);
1082   assert(rc == MEMCACHED_SUCCESS);
1083   assert(new_number == 2);
1084
1085   rc= memcached_decrement(memc, key, strlen(key),
1086                           1, &new_number);
1087   assert(rc == MEMCACHED_SUCCESS);
1088   assert(new_number == 1);
1089
1090   return 0;
1091 }
1092
1093 static test_return  decrement_with_initial_test(memcached_st *memc)
1094 {
1095   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1096   {
1097     uint64_t new_number;
1098     memcached_return rc;
1099     char *key= "number";
1100     uint64_t initial= 3;
1101
1102     rc= memcached_decrement_with_initial(memc, key, strlen(key),
1103                                          1, initial, 0, &new_number);
1104     assert(rc == MEMCACHED_SUCCESS);
1105     assert(new_number == initial);
1106
1107     rc= memcached_decrement_with_initial(memc, key, strlen(key),
1108                                          1, initial, 0, &new_number);
1109     assert(rc == MEMCACHED_SUCCESS);
1110     assert(new_number == (initial - 1));
1111   }
1112   return 0;
1113 }
1114
1115 static test_return  quit_test(memcached_st *memc)
1116 {
1117   memcached_return rc;
1118   char *key= "fudge";
1119   char *value= "sanford and sun";
1120
1121   rc= memcached_set(memc, key, strlen(key),
1122                     value, strlen(value),
1123                     (time_t)10, (uint32_t)3);
1124   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1125   memcached_quit(memc);
1126
1127   rc= memcached_set(memc, key, strlen(key),
1128                     value, strlen(value),
1129                     (time_t)50, (uint32_t)9);
1130   assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1131
1132   return 0;
1133 }
1134
1135 static test_return  mget_result_test(memcached_st *memc)
1136 {
1137   memcached_return rc;
1138   char *keys[]= {"fudge", "son", "food"};
1139   size_t key_length[]= {5, 3, 4};
1140   unsigned int x;
1141
1142   memcached_result_st results_obj;
1143   memcached_result_st *results;
1144
1145   results= memcached_result_create(memc, &results_obj);
1146   assert(results);
1147   assert(&results_obj == results);
1148
1149   /* We need to empty the server before continueing test */
1150   rc= memcached_flush(memc, 0);
1151   assert(rc == MEMCACHED_SUCCESS);
1152
1153   rc= memcached_mget(memc, keys, key_length, 3);
1154   assert(rc == MEMCACHED_SUCCESS);
1155
1156   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1157   {
1158     assert(results);
1159   }
1160
1161   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1162   assert(!results);
1163   assert(rc == MEMCACHED_END);
1164
1165   for (x= 0; x < 3; x++)
1166   {
1167     rc= memcached_set(memc, keys[x], key_length[x],
1168                       keys[x], key_length[x],
1169                       (time_t)50, (uint32_t)9);
1170     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1171   }
1172
1173   rc= memcached_mget(memc, keys, key_length, 3);
1174   assert(rc == MEMCACHED_SUCCESS);
1175
1176   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1177   {
1178     assert(results);
1179     assert(&results_obj == results);
1180     assert(rc == MEMCACHED_SUCCESS);
1181     assert(memcached_result_key_length(results) == memcached_result_length(results));
1182     assert(!memcmp(memcached_result_key_value(results),
1183                    memcached_result_value(results),
1184                    memcached_result_length(results)));
1185   }
1186
1187   memcached_result_free(&results_obj);
1188
1189   return 0;
1190 }
1191
1192 static test_return  mget_result_alloc_test(memcached_st *memc)
1193 {
1194   memcached_return rc;
1195   char *keys[]= {"fudge", "son", "food"};
1196   size_t key_length[]= {5, 3, 4};
1197   unsigned int x;
1198
1199   memcached_result_st *results;
1200
1201   /* We need to empty the server before continueing test */
1202   rc= memcached_flush(memc, 0);
1203   assert(rc == MEMCACHED_SUCCESS);
1204
1205   rc= memcached_mget(memc, keys, key_length, 3);
1206   assert(rc == MEMCACHED_SUCCESS);
1207
1208   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
1209   {
1210     assert(results);
1211   }
1212   assert(!results);
1213   assert(rc == MEMCACHED_END);
1214
1215   for (x= 0; x < 3; x++)
1216   {
1217     rc= memcached_set(memc, keys[x], key_length[x],
1218                       keys[x], key_length[x],
1219                       (time_t)50, (uint32_t)9);
1220     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1221   }
1222
1223   rc= memcached_mget(memc, keys, key_length, 3);
1224   assert(rc == MEMCACHED_SUCCESS);
1225
1226   x= 0;
1227   while ((results= memcached_fetch_result(memc, NULL, &rc)))
1228   {
1229     assert(results);
1230     assert(rc == MEMCACHED_SUCCESS);
1231     assert(memcached_result_key_length(results) == memcached_result_length(results));
1232     assert(!memcmp(memcached_result_key_value(results),
1233                    memcached_result_value(results),
1234                    memcached_result_length(results)));
1235     memcached_result_free(results);
1236     x++;
1237   }
1238
1239   return 0;
1240 }
1241
1242 /* Count the results */
1243 static memcached_return callback_counter(memcached_st *ptr __attribute__((unused)),
1244                                      memcached_result_st *result __attribute__((unused)),
1245                                      void *context)
1246 {
1247   unsigned int *counter= (unsigned int *)context;
1248
1249   *counter= *counter + 1;
1250
1251   return MEMCACHED_SUCCESS;
1252 }
1253
1254 static test_return  mget_result_function(memcached_st *memc)
1255 {
1256   memcached_return rc;
1257   char *keys[]= {"fudge", "son", "food"};
1258   size_t key_length[]= {5, 3, 4};
1259   unsigned int x;
1260   unsigned int counter;
1261   memcached_execute_function callbacks[1];
1262
1263   /* We need to empty the server before continueing test */
1264   rc= memcached_flush(memc, 0);
1265   for (x= 0; x < 3; x++)
1266   {
1267     rc= memcached_set(memc, keys[x], key_length[x],
1268                       keys[x], key_length[x],
1269                       (time_t)50, (uint32_t)9);
1270     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1271   }
1272
1273   rc= memcached_mget(memc, keys, key_length, 3);
1274   assert(rc == MEMCACHED_SUCCESS);
1275
1276   callbacks[0]= &callback_counter;
1277   counter= 0;
1278   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1279
1280   assert(counter == 3);
1281
1282   return 0;
1283 }
1284
1285 static test_return  mget_test(memcached_st *memc)
1286 {
1287   memcached_return rc;
1288   char *keys[]= {"fudge", "son", "food"};
1289   size_t key_length[]= {5, 3, 4};
1290   unsigned int x;
1291   uint32_t flags;
1292
1293   char return_key[MEMCACHED_MAX_KEY];
1294   size_t return_key_length;
1295   char *return_value;
1296   size_t return_value_length;
1297
1298   /* We need to empty the server before continueing test */
1299   rc= memcached_flush(memc, 0);
1300   assert(rc == MEMCACHED_SUCCESS);
1301
1302   rc= memcached_mget(memc, keys, key_length, 3);
1303   assert(rc == MEMCACHED_SUCCESS);
1304
1305   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1306                       &return_value_length, &flags, &rc)) != NULL)
1307   {
1308     assert(return_value);
1309   }
1310   assert(!return_value);
1311   assert(return_value_length == 0);
1312   assert(rc == MEMCACHED_END);
1313
1314   for (x= 0; x < 3; x++)
1315   {
1316     rc= memcached_set(memc, keys[x], key_length[x],
1317                       keys[x], key_length[x],
1318                       (time_t)50, (uint32_t)9);
1319     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1320   }
1321
1322   rc= memcached_mget(memc, keys, key_length, 3);
1323   assert(rc == MEMCACHED_SUCCESS);
1324
1325   x= 0;
1326   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1327                                         &return_value_length, &flags, &rc)))
1328   {
1329     assert(return_value);
1330     assert(rc == MEMCACHED_SUCCESS);
1331     assert(return_key_length == return_value_length);
1332     assert(!memcmp(return_value, return_key, return_value_length));
1333     free(return_value);
1334     x++;
1335   }
1336
1337   return 0;
1338 }
1339
1340 static test_return  get_stats_keys(memcached_st *memc)
1341 {
1342  char **list;
1343  char **ptr;
1344  memcached_stat_st stat;
1345  memcached_return rc;
1346
1347  list= memcached_stat_get_keys(memc, &stat, &rc);
1348  assert(rc == MEMCACHED_SUCCESS);
1349  for (ptr= list; *ptr; ptr++)
1350    assert(*ptr);
1351  fflush(stdout);
1352
1353  free(list);
1354
1355  return 0;
1356 }
1357
1358 static test_return  version_string_test(memcached_st *memc __attribute__((unused)))
1359 {
1360   const char *version_string;
1361
1362   version_string= memcached_lib_version();
1363
1364   assert(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1365
1366   return 0;
1367 }
1368
1369 static test_return  get_stats(memcached_st *memc)
1370 {
1371  unsigned int x;
1372  char **list;
1373  char **ptr;
1374  memcached_return rc;
1375  memcached_stat_st *stat;
1376
1377  stat= memcached_stat(memc, NULL, &rc);
1378  assert(rc == MEMCACHED_SUCCESS);
1379
1380  assert(rc == MEMCACHED_SUCCESS);
1381  assert(stat);
1382
1383  for (x= 0; x < memcached_server_count(memc); x++)
1384  {
1385    list= memcached_stat_get_keys(memc, stat+x, &rc);
1386    assert(rc == MEMCACHED_SUCCESS);
1387    for (ptr= list; *ptr; ptr++);
1388
1389    free(list);
1390  }
1391
1392  memcached_stat_free(NULL, stat);
1393
1394   return 0;
1395 }
1396
1397 static test_return  add_host_test(memcached_st *memc)
1398 {
1399   unsigned int x;
1400   memcached_server_st *servers;
1401   memcached_return rc;
1402   char servername[]= "0.example.com";
1403
1404   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1405   assert(servers);
1406   assert(1 == memcached_server_list_count(servers));
1407
1408   for (x= 2; x < 20; x++)
1409   {
1410     char buffer[SMALL_STRING_LEN];
1411
1412     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1413     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1414                                      &rc);
1415     assert(rc == MEMCACHED_SUCCESS);
1416     assert(x == memcached_server_list_count(servers));
1417   }
1418
1419   rc= memcached_server_push(memc, servers);
1420   assert(rc == MEMCACHED_SUCCESS);
1421   rc= memcached_server_push(memc, servers);
1422   assert(rc == MEMCACHED_SUCCESS);
1423
1424   memcached_server_list_free(servers);
1425
1426   return 0;
1427 }
1428
1429 static memcached_return  clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *clone __attribute__((unused)))
1430 {
1431   return MEMCACHED_SUCCESS;
1432 }
1433
1434 static memcached_return  cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
1435 {
1436   return MEMCACHED_SUCCESS;
1437 }
1438
1439 static test_return  callback_test(memcached_st *memc)
1440 {
1441   /* Test User Data */
1442   {
1443     int x= 5;
1444     int *test_ptr;
1445     memcached_return rc;
1446
1447     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1448     assert(rc == MEMCACHED_SUCCESS);
1449     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1450     assert(*test_ptr == x);
1451   }
1452
1453   /* Test Clone Callback */
1454   {
1455     memcached_clone_func temp_function;
1456     memcached_return rc;
1457
1458     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, (void*)clone_test_callback);
1459     assert(rc == MEMCACHED_SUCCESS);
1460     temp_function= (memcached_clone_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1461     assert(temp_function == clone_test_callback);
1462   }
1463
1464   /* Test Cleanup Callback */
1465   {
1466     memcached_cleanup_func temp_function;
1467     memcached_return rc;
1468
1469     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, (void*)cleanup_test_callback);
1470     assert(rc == MEMCACHED_SUCCESS);
1471     temp_function= (memcached_cleanup_func)memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1472     assert(temp_function == cleanup_test_callback);
1473   }
1474
1475   return 0;
1476 }
1477
1478 /* We don't test the behavior itself, we test the switches */
1479 static test_return  behavior_test(memcached_st *memc)
1480 {
1481   uint64_t value;
1482   uint32_t set= 1;
1483
1484   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1485   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1486   assert(value == 1);
1487
1488   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1489   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1490   assert(value == 1);
1491
1492   set= MEMCACHED_HASH_MD5;
1493   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1494   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1495   assert(value == MEMCACHED_HASH_MD5);
1496
1497   set= 0;
1498
1499   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1500   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1501   assert(value == 0);
1502
1503   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1504   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1505   assert(value == 0);
1506
1507   set= MEMCACHED_HASH_DEFAULT;
1508   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1509   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1510   assert(value == MEMCACHED_HASH_DEFAULT);
1511
1512   set= MEMCACHED_HASH_CRC;
1513   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1514   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1515   assert(value == MEMCACHED_HASH_CRC);
1516
1517   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1518   assert(value > 0);
1519
1520   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1521   assert(value > 0);
1522
1523   return 0;
1524 }
1525
1526 /* Test case provided by Cal Haldenbrand */
1527 static test_return  user_supplied_bug1(memcached_st *memc)
1528 {
1529   unsigned int setter= 1;
1530   unsigned int x;
1531
1532   unsigned long long total= 0;
1533   uint32_t size= 0;
1534   char key[10];
1535   char randomstuff[6 * 1024];
1536   memcached_return rc;
1537
1538   memset(randomstuff, 0, 6 * 1024);
1539
1540   /* We just keep looking at the same values over and over */
1541   srandom(10);
1542
1543   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1544   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1545
1546
1547   /* add key */
1548   for (x= 0 ; total < 20 * 1024576 ; x++ )
1549   {
1550     unsigned int j= 0;
1551
1552     size= (rand() % ( 5 * 1024 ) ) + 400;
1553     memset(randomstuff, 0, 6 * 1024);
1554     assert(size < 6 * 1024); /* Being safe here */
1555
1556     for (j= 0 ; j < size ;j++)
1557       randomstuff[j] = (char) (rand() % 26) + 97;
1558
1559     total += size;
1560     sprintf(key, "%d", x);
1561     rc = memcached_set(memc, key, strlen(key),
1562                        randomstuff, strlen(randomstuff), 10, 0);
1563     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1564     /* If we fail, lets try again */
1565     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
1566       rc = memcached_set(memc, key, strlen(key),
1567                          randomstuff, strlen(randomstuff), 10, 0);
1568     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1569   }
1570
1571   return 0;
1572 }
1573
1574 /* Test case provided by Cal Haldenbrand */
1575 static test_return  user_supplied_bug2(memcached_st *memc)
1576 {
1577   int errors;
1578   unsigned int setter;
1579   unsigned int x;
1580   unsigned long long total;
1581
1582   setter= 1;
1583   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1584   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1585 #ifdef NOT_YET
1586   setter = 20 * 1024576;
1587   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1588   setter = 20 * 1024576;
1589   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1590   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1591   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1592
1593   for (x= 0, errors= 0, total= 0 ; total < 20 * 1024576 ; x++)
1594 #endif
1595
1596   for (x= 0, errors= 0, total= 0 ; total < 24576 ; x++)
1597   {
1598     memcached_return rc= MEMCACHED_SUCCESS;
1599     char buffer[SMALL_STRING_LEN];
1600     uint32_t flags= 0;
1601     size_t val_len= 0;
1602     char *getval;
1603
1604     memset(buffer, 0, SMALL_STRING_LEN);
1605
1606     snprintf(buffer, SMALL_STRING_LEN, "%u", x);
1607     getval= memcached_get(memc, buffer, strlen(buffer),
1608                            &val_len, &flags, &rc);
1609     if (rc != MEMCACHED_SUCCESS)
1610     {
1611       if (rc == MEMCACHED_NOTFOUND)
1612         errors++;
1613       else
1614       {
1615         WATCHPOINT_ERROR(rc);
1616         assert(0);
1617       }
1618
1619       continue;
1620     }
1621     total+= val_len;
1622     errors= 0;
1623     free(getval);
1624   }
1625
1626   return 0;
1627 }
1628
1629 /* Do a large mget() over all the keys we think exist */
1630 #define KEY_COUNT 3000 // * 1024576
1631 static test_return  user_supplied_bug3(memcached_st *memc)
1632 {
1633   memcached_return rc;
1634   unsigned int setter;
1635   unsigned int x;
1636   char **keys;
1637   size_t key_lengths[KEY_COUNT];
1638
1639   setter= 1;
1640   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
1641   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
1642 #ifdef NOT_YET
1643   setter = 20 * 1024576;
1644   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
1645   setter = 20 * 1024576;
1646   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
1647   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1648   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1649 #endif
1650
1651   keys= (char **)malloc(sizeof(char *) * KEY_COUNT);
1652   assert(keys);
1653   memset(keys, 0, (sizeof(char *) * KEY_COUNT));
1654   for (x= 0; x < KEY_COUNT; x++)
1655   {
1656     char buffer[30];
1657
1658     snprintf(buffer, 30, "%u", x);
1659     keys[x]= strdup(buffer);
1660     key_lengths[x]= strlen(keys[x]);
1661   }
1662
1663   rc= memcached_mget(memc, keys, key_lengths, KEY_COUNT);
1664   assert(rc == MEMCACHED_SUCCESS);
1665
1666   /* Turn this into a help function */
1667   {
1668     char return_key[MEMCACHED_MAX_KEY];
1669     size_t return_key_length;
1670     char *return_value;
1671     size_t return_value_length;
1672     uint32_t flags;
1673
1674     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1675                                           &return_value_length, &flags, &rc)))
1676     {
1677       assert(return_value);
1678       assert(rc == MEMCACHED_SUCCESS);
1679       free(return_value);
1680     }
1681   }
1682
1683   for (x= 0; x < KEY_COUNT; x++)
1684     free(keys[x]);
1685   free(keys);
1686
1687   return 0;
1688 }
1689
1690 /* Make sure we behave properly if server list has no values */
1691 static test_return  user_supplied_bug4(memcached_st *memc)
1692 {
1693   memcached_return rc;
1694   char *keys[]= {"fudge", "son", "food"};
1695   size_t key_length[]= {5, 3, 4};
1696   unsigned int x;
1697   uint32_t flags;
1698   char return_key[MEMCACHED_MAX_KEY];
1699   size_t return_key_length;
1700   char *return_value;
1701   size_t return_value_length;
1702
1703   /* Here we free everything before running a bunch of mget tests */
1704   {
1705     memcached_server_list_free(memc->hosts);
1706     memc->hosts= NULL;
1707     memc->number_of_hosts= 0;
1708   }
1709
1710
1711   /* We need to empty the server before continueing test */
1712   rc= memcached_flush(memc, 0);
1713   assert(rc == MEMCACHED_NO_SERVERS);
1714
1715   rc= memcached_mget(memc, keys, key_length, 3);
1716   assert(rc == MEMCACHED_NO_SERVERS);
1717
1718   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1719                       &return_value_length, &flags, &rc)) != NULL)
1720   {
1721     assert(return_value);
1722   }
1723   assert(!return_value);
1724   assert(return_value_length == 0);
1725   assert(rc == MEMCACHED_NO_SERVERS);
1726
1727   for (x= 0; x < 3; x++)
1728   {
1729     rc= memcached_set(memc, keys[x], key_length[x],
1730                       keys[x], key_length[x],
1731                       (time_t)50, (uint32_t)9);
1732     assert(rc == MEMCACHED_NO_SERVERS);
1733   }
1734
1735   rc= memcached_mget(memc, keys, key_length, 3);
1736   assert(rc == MEMCACHED_NO_SERVERS);
1737
1738   x= 0;
1739   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1740                                         &return_value_length, &flags, &rc)))
1741   {
1742     assert(return_value);
1743     assert(rc == MEMCACHED_SUCCESS);
1744     assert(return_key_length == return_value_length);
1745     assert(!memcmp(return_value, return_key, return_value_length));
1746     free(return_value);
1747     x++;
1748   }
1749
1750   return 0;
1751 }
1752
1753 #define VALUE_SIZE_BUG5 1048064
1754 static test_return  user_supplied_bug5(memcached_st *memc)
1755 {
1756   memcached_return rc;
1757   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1758   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1759   char return_key[MEMCACHED_MAX_KEY];
1760   size_t return_key_length;
1761   char *value;
1762   size_t value_length;
1763   uint32_t flags;
1764   unsigned int count;
1765   unsigned int x;
1766   char insert_data[VALUE_SIZE_BUG5];
1767
1768   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1769     insert_data[x]= rand();
1770
1771   memcached_flush(memc, 0);
1772   value= memcached_get(memc, keys[0], key_length[0],
1773                         &value_length, &flags, &rc);
1774   assert(value == NULL);
1775   rc= memcached_mget(memc, keys, key_length, 4);
1776
1777   count= 0;
1778   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1779                                         &value_length, &flags, &rc)))
1780     count++;
1781   assert(count == 0);
1782
1783   for (x= 0; x < 4; x++)
1784   {
1785     rc= memcached_set(memc, keys[x], key_length[x],
1786                       insert_data, VALUE_SIZE_BUG5,
1787                       (time_t)0, (uint32_t)0);
1788     assert(rc == MEMCACHED_SUCCESS);
1789   }
1790
1791   for (x= 0; x < 10; x++)
1792   {
1793     value= memcached_get(memc, keys[0], key_length[0],
1794                          &value_length, &flags, &rc);
1795     assert(value);
1796     free(value);
1797
1798     rc= memcached_mget(memc, keys, key_length, 4);
1799     count= 0;
1800     while ((value= memcached_fetch(memc, return_key, &return_key_length,
1801                                           &value_length, &flags, &rc)))
1802     {
1803       count++;
1804       free(value);
1805     }
1806     assert(count == 4);
1807   }
1808
1809   return 0;
1810 }
1811
1812 static test_return  user_supplied_bug6(memcached_st *memc)
1813 {
1814   memcached_return rc;
1815   char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
1816   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
1817   char return_key[MEMCACHED_MAX_KEY];
1818   size_t return_key_length;
1819   char *value;
1820   size_t value_length;
1821   uint32_t flags;
1822   unsigned int count;
1823   unsigned int x;
1824   char insert_data[VALUE_SIZE_BUG5];
1825
1826   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1827     insert_data[x]= rand();
1828
1829   memcached_flush(memc, 0);
1830   value= memcached_get(memc, keys[0], key_length[0],
1831                         &value_length, &flags, &rc);
1832   assert(value == NULL);
1833   assert(rc == MEMCACHED_NOTFOUND);
1834   rc= memcached_mget(memc, keys, key_length, 4);
1835   assert(rc == MEMCACHED_SUCCESS);
1836
1837   count= 0;
1838   while ((value= memcached_fetch(memc, return_key, &return_key_length,
1839                                         &value_length, &flags, &rc)))
1840     count++;
1841   assert(count == 0);
1842   assert(rc == MEMCACHED_END);
1843
1844   for (x= 0; x < 4; x++)
1845   {
1846     rc= memcached_set(memc, keys[x], key_length[x],
1847                       insert_data, VALUE_SIZE_BUG5,
1848                       (time_t)0, (uint32_t)0);
1849     assert(rc == MEMCACHED_SUCCESS);
1850   }
1851
1852   for (x= 0; x < 2; x++)
1853   {
1854     value= memcached_get(memc, keys[0], key_length[0],
1855                          &value_length, &flags, &rc);
1856     assert(value);
1857     free(value);
1858
1859     rc= memcached_mget(memc, keys, key_length, 4);
1860     assert(rc == MEMCACHED_SUCCESS);
1861     count= 3;
1862     /* We test for purge of partial complete fetches */
1863     for (count= 3; count; count--)
1864     {
1865       value= memcached_fetch(memc, return_key, &return_key_length,
1866                              &value_length, &flags, &rc);
1867       assert(rc == MEMCACHED_SUCCESS);
1868       assert(!(memcmp(value, insert_data, value_length)));
1869       assert(value_length);
1870       free(value);
1871     }
1872   }
1873
1874   return 0;
1875 }
1876
1877 static test_return  user_supplied_bug8(memcached_st *memc __attribute__((unused)))
1878 {
1879   memcached_return rc;
1880   memcached_st *mine;
1881   memcached_st *clone;
1882
1883   memcached_server_st *servers;
1884   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";
1885
1886   servers= memcached_servers_parse(server_list);
1887   assert(servers);
1888
1889   mine= memcached_create(NULL);
1890   rc= memcached_server_push(mine, servers);
1891   assert(rc == MEMCACHED_SUCCESS);
1892   memcached_server_list_free(servers);
1893
1894   assert(mine);
1895   clone= memcached_clone(NULL, mine);
1896
1897   memcached_quit(mine);
1898   memcached_quit(clone);
1899
1900
1901   memcached_free(mine);
1902   memcached_free(clone);
1903
1904   return 0;
1905 }
1906
1907 /* Test flag store/retrieve */
1908 static test_return  user_supplied_bug7(memcached_st *memc)
1909 {
1910   memcached_return rc;
1911   char *keys= "036790384900";
1912   size_t key_length=  strlen("036790384900");
1913   char return_key[MEMCACHED_MAX_KEY];
1914   size_t return_key_length;
1915   char *value;
1916   size_t value_length;
1917   uint32_t flags;
1918   unsigned int x;
1919   char insert_data[VALUE_SIZE_BUG5];
1920
1921   for (x= 0; x < VALUE_SIZE_BUG5; x++)
1922     insert_data[x]= rand();
1923
1924   memcached_flush(memc, 0);
1925
1926   flags= 245;
1927   rc= memcached_set(memc, keys, key_length,
1928                     insert_data, VALUE_SIZE_BUG5,
1929                     (time_t)0, flags);
1930   assert(rc == MEMCACHED_SUCCESS);
1931
1932   flags= 0;
1933   value= memcached_get(memc, keys, key_length,
1934                         &value_length, &flags, &rc);
1935   assert(flags == 245);
1936   assert(value);
1937   free(value);
1938
1939   rc= memcached_mget(memc, &keys, &key_length, 1);
1940
1941   flags= 0;
1942   value= memcached_fetch(memc, return_key, &return_key_length,
1943                          &value_length, &flags, &rc);
1944   assert(flags == 245);
1945   assert(value);
1946   free(value);
1947
1948
1949   return 0;
1950 }
1951
1952 static test_return  user_supplied_bug9(memcached_st *memc)
1953 {
1954   memcached_return rc;
1955   char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
1956   size_t key_length[3];
1957   unsigned int x;
1958   uint32_t flags;
1959   unsigned count= 0;
1960
1961   char return_key[MEMCACHED_MAX_KEY];
1962   size_t return_key_length;
1963   char *return_value;
1964   size_t return_value_length;
1965
1966
1967   key_length[0]= strlen("UDATA:edevil@sapo.pt");
1968   key_length[1]= strlen("fudge&*@#");
1969   key_length[2]= strlen("for^#@&$not");
1970
1971
1972   for (x= 0; x < 3; x++)
1973   {
1974     rc= memcached_set(memc, keys[x], key_length[x],
1975                       keys[x], key_length[x],
1976                       (time_t)50, (uint32_t)9);
1977     assert(rc == MEMCACHED_SUCCESS);
1978   }
1979
1980   rc= memcached_mget(memc, keys, key_length, 3);
1981   assert(rc == MEMCACHED_SUCCESS);
1982
1983   /* We need to empty the server before continueing test */
1984   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1985                       &return_value_length, &flags, &rc)) != NULL)
1986   {
1987     assert(return_value);
1988     free(return_value);
1989     count++;
1990   }
1991   assert(count == 3);
1992
1993   return 0;
1994 }
1995
1996 /* We are testing with aggressive timeout to get failures */
1997 static test_return  user_supplied_bug10(memcached_st *memc)
1998 {
1999   char *key= "foo";
2000   char *value;
2001   size_t value_length= 512;
2002   unsigned int x;
2003   int key_len= 3;
2004   memcached_return rc;
2005   unsigned int set= 1;
2006   memcached_st *mclone= memcached_clone(NULL, memc);
2007   int32_t timeout;
2008
2009   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2010   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2011   timeout= 2;
2012   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
2013
2014   value = (char*)malloc(value_length * sizeof(char));
2015
2016   for (x= 0; x < value_length; x++)
2017     value[x]= (char) (x % 127);
2018
2019   for (x= 1; x <= 100000; ++x)
2020   {
2021     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2022
2023     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
2024            rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
2025
2026     if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
2027       x--;
2028   }
2029
2030   free(value);
2031   memcached_free(mclone);
2032
2033   return 0;
2034 }
2035
2036 /*
2037   We are looking failures in the async protocol
2038 */
2039 static test_return  user_supplied_bug11(memcached_st *memc)
2040 {
2041   char *key= "foo";
2042   char *value;
2043   size_t value_length= 512;
2044   unsigned int x;
2045   int key_len= 3;
2046   memcached_return rc;
2047   unsigned int set= 1;
2048   int32_t timeout;
2049   memcached_st *mclone= memcached_clone(NULL, memc);
2050
2051   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2052   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2053   timeout= -1;
2054   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
2055
2056   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2057
2058   assert(timeout == -1);
2059
2060   value = (char*)malloc(value_length * sizeof(char));
2061
2062   for (x= 0; x < value_length; x++)
2063     value[x]= (char) (x % 127);
2064
2065   for (x= 1; x <= 100000; ++x)
2066   {
2067     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2068   }
2069
2070   free(value);
2071   memcached_free(mclone);
2072
2073   return 0;
2074 }
2075
2076 /*
2077   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2078 */
2079 static test_return  user_supplied_bug12(memcached_st *memc)
2080 {
2081   memcached_return rc;
2082   uint32_t flags;
2083   size_t value_length;
2084   char *value;
2085   uint64_t number_value;
2086
2087   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2088                         &value_length, &flags, &rc);
2089   assert(value == NULL);
2090   assert(rc == MEMCACHED_NOTFOUND);
2091
2092   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2093                           1, &number_value);
2094
2095   assert(value == NULL);
2096   /* The binary protocol will set the key if it doesn't exist */
2097   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2098     assert(rc == MEMCACHED_SUCCESS);
2099   else
2100     assert(rc == MEMCACHED_NOTFOUND);
2101
2102   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2103
2104   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2105                         &value_length, &flags, &rc);
2106   assert(value);
2107   assert(rc == MEMCACHED_SUCCESS);
2108   free(value);
2109
2110   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2111                           1, &number_value);
2112   assert(number_value == 2);
2113   assert(rc == MEMCACHED_SUCCESS);
2114
2115   return 0;
2116 }
2117
2118 /*
2119   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2120   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2121  */
2122 static test_return  user_supplied_bug13(memcached_st *memc)
2123 {
2124   char key[] = "key34567890";
2125   char *overflow;
2126   memcached_return rc;
2127   size_t overflowSize;
2128
2129   char commandFirst[]= "set key34567890 0 0 ";
2130   char commandLast[] = " \r\n"; /* first line of command sent to server */
2131   size_t commandLength;
2132   size_t testSize;
2133
2134   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2135
2136   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2137
2138   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2139   {
2140     overflow= malloc(testSize);
2141     assert(overflow != NULL);
2142
2143     memset(overflow, 'x', testSize);
2144     rc= memcached_set(memc, key, strlen(key),
2145                       overflow, testSize, 0, 0);
2146     assert(rc == MEMCACHED_SUCCESS);
2147     free(overflow);
2148   }
2149
2150   return 0;
2151 }
2152
2153
2154 /*
2155   Test values of many different sizes
2156   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2157   set key34567890 0 0 8169 \r\n
2158   is sent followed by buffer of size 8169, followed by 8169
2159  */
2160 static test_return  user_supplied_bug14(memcached_st *memc)
2161 {
2162   int setter= 1;
2163   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2164   memcached_return rc;
2165   char *key= "foo";
2166   char *value;
2167   size_t value_length= 18000;
2168   char *string;
2169   size_t string_length;
2170   uint32_t flags;
2171   unsigned int x;
2172   size_t current_length;
2173
2174   value = (char*)malloc(value_length);
2175   assert(value);
2176
2177   for (x= 0; x < value_length; x++)
2178     value[x] = (char) (x % 127);
2179
2180   for (current_length= 0; current_length < value_length; current_length++)
2181   {
2182     rc= memcached_set(memc, key, strlen(key),
2183                       value, current_length,
2184                       (time_t)0, (uint32_t)0);
2185     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2186
2187     string= memcached_get(memc, key, strlen(key),
2188                           &string_length, &flags, &rc);
2189
2190     assert(rc == MEMCACHED_SUCCESS);
2191     assert(string_length == current_length);
2192     assert(!memcmp(string, value, string_length));
2193
2194     free(string);
2195   }
2196
2197   free(value);
2198
2199   return 0;
2200 }
2201
2202 /*
2203   Look for zero length value problems
2204   */
2205 static test_return  user_supplied_bug15(memcached_st *memc)
2206 {
2207   uint32_t x;
2208   memcached_return rc;
2209   char *key= "mykey";
2210   char *value;
2211   size_t length;
2212   uint32_t flags;
2213
2214   for (x= 0; x < 2; x++)
2215   {
2216     rc= memcached_set(memc, key, strlen(key),
2217                       NULL, 0,
2218                       (time_t)0, (uint32_t)0);
2219
2220     assert(rc == MEMCACHED_SUCCESS);
2221
2222     value= memcached_get(memc, key, strlen(key),
2223                          &length, &flags, &rc);
2224
2225     assert(rc == MEMCACHED_SUCCESS);
2226     assert(value == NULL);
2227     assert(length == 0);
2228     assert(flags == 0);
2229
2230     value= memcached_get(memc, key, strlen(key),
2231                          &length, &flags, &rc);
2232
2233     assert(rc == MEMCACHED_SUCCESS);
2234     assert(value == NULL);
2235     assert(length == 0);
2236     assert(flags == 0);
2237   }
2238
2239   return 0;
2240 }
2241
2242 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2243 static test_return  user_supplied_bug16(memcached_st *memc)
2244 {
2245   memcached_return rc;
2246   char *key= "mykey";
2247   char *value;
2248   size_t length;
2249   uint32_t flags;
2250
2251   rc= memcached_set(memc, key, strlen(key),
2252                     NULL, 0,
2253                     (time_t)0, UINT32_MAX);
2254
2255   assert(rc == MEMCACHED_SUCCESS);
2256
2257   value= memcached_get(memc, key, strlen(key),
2258                        &length, &flags, &rc);
2259
2260   assert(rc == MEMCACHED_SUCCESS);
2261   assert(value == NULL);
2262   assert(length == 0);
2263   assert(flags == UINT32_MAX);
2264
2265   return 0;
2266 }
2267
2268 /* Check the validity of chinese key*/
2269 static test_return  user_supplied_bug17(memcached_st *memc)
2270 {
2271     memcached_return rc;
2272     char *key= "豆瓣";
2273     char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2274     char *value2;
2275     size_t length;
2276     uint32_t flags;
2277
2278     rc= memcached_set(memc, key, strlen(key),
2279             value, strlen(value),
2280             (time_t)0, 0);
2281
2282     assert(rc == MEMCACHED_SUCCESS);
2283
2284     value2= memcached_get(memc, key, strlen(key),
2285             &length, &flags, &rc);
2286
2287     assert(length==strlen(value));
2288     assert(rc == MEMCACHED_SUCCESS);
2289     assert(memcmp(value, value2, length)==0);
2290     free(value2);
2291
2292     return 0;
2293 }
2294
2295 /*
2296   From Andrei on IRC
2297 */
2298
2299 test_return user_supplied_bug19(memcached_st *memc)
2300 {
2301   memcached_st *m;
2302   memcached_server_st *s;
2303   memcached_return res;
2304
2305   (void)memc;
2306
2307   m= memcached_create(NULL);
2308   memcached_server_add_with_weight(m, "localhost", 11311, 100);
2309   memcached_server_add_with_weight(m, "localhost", 11312, 100);
2310
2311   s= memcached_server_by_key(m, "a", 1, &res);
2312   memcached_server_free(s);
2313
2314   memcached_free(m);
2315
2316   return 0;
2317 }
2318
2319 /* CAS test from Andei */
2320 test_return user_supplied_bug20(memcached_st *memc)
2321 {
2322   memcached_return status;
2323   memcached_result_st *result, result_obj;
2324   char *key = "abc";
2325   size_t key_len = strlen("abc");
2326   char *value = "foobar";
2327   size_t value_len = strlen(value);
2328
2329   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2330
2331   status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2332   assert(status == MEMCACHED_SUCCESS);
2333
2334   status = memcached_mget(memc, &key, &key_len, 1);
2335   assert(status == MEMCACHED_SUCCESS);
2336
2337   result= memcached_result_create(memc, &result_obj);
2338   assert(result);
2339
2340   memcached_result_create(memc, &result_obj);
2341   result= memcached_fetch_result(memc, &result_obj, &status);
2342
2343   assert(result);
2344   assert(status == MEMCACHED_SUCCESS);
2345
2346   memcached_result_free(result);
2347
2348   return 0;
2349 }
2350
2351 #include "ketama_test_cases.h"
2352 test_return user_supplied_bug18(memcached_st *trash)
2353 {
2354   memcached_return rc;
2355   int value;
2356   int x;
2357   memcached_server_st *server_pool;
2358   memcached_st *memc;
2359
2360   (void)trash;
2361
2362   memc= memcached_create(NULL);
2363   assert(memc);
2364
2365   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2366   assert(rc == MEMCACHED_SUCCESS);
2367
2368   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2369   assert(value == 1);
2370
2371   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2372   assert(rc == MEMCACHED_SUCCESS);
2373
2374   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2375   assert(value == MEMCACHED_HASH_MD5);
2376
2377   server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2378   memcached_server_push(memc, server_pool);
2379
2380   /* verify that the server list was parsed okay. */
2381   assert(memc->number_of_hosts == 8);
2382   assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2383   assert(server_pool[0].port == 11211);
2384   assert(server_pool[0].weight == 600);
2385   assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2386   assert(server_pool[2].port == 11211);
2387   assert(server_pool[2].weight == 200);
2388   assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2389   assert(server_pool[7].port == 11211);
2390   assert(server_pool[7].weight == 100);
2391
2392   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2393    * us test the boundary wraparound.
2394    */
2395   assert(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
2396
2397   /* verify the standard ketama set. */
2398   for (x= 0; x < 99; x++)
2399   {
2400     uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2401     char *hostname = memc->hosts[server_idx].hostname;
2402     assert(strcmp(hostname, test_cases[x].server) == 0);
2403   }
2404
2405   memcached_server_list_free(server_pool);
2406   memcached_free(memc);
2407
2408   return 0;
2409 }
2410
2411 test_return auto_eject_hosts(memcached_st *trash)
2412 {
2413   memcached_return rc;
2414   memcached_st *memc= memcached_create(NULL);
2415   assert(memc);
2416
2417   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2418   assert(rc == MEMCACHED_SUCCESS);
2419
2420   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2421   assert(value == 1);
2422
2423   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2424   assert(rc == MEMCACHED_SUCCESS);
2425
2426   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2427   assert(value == MEMCACHED_HASH_MD5);
2428
2429     /* server should be removed when in delay */
2430   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
2431   assert(rc == MEMCACHED_SUCCESS);
2432
2433   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
2434   assert(value == 1);
2435
2436   memcached_server_st *server_pool;
2437   server_pool = memcached_servers_parse("10.0.1.1:11211 600,10.0.1.2:11211 300,10.0.1.3:11211 200,10.0.1.4:11211 350,10.0.1.5:11211 1000,10.0.1.6:11211 800,10.0.1.7:11211 950,10.0.1.8:11211 100");
2438   memcached_server_push(memc, server_pool);
2439
2440   /* verify that the server list was parsed okay. */
2441   assert(memc->number_of_hosts == 8);
2442   assert(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2443   assert(server_pool[0].port == 11211);
2444   assert(server_pool[0].weight == 600);
2445   assert(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2446   assert(server_pool[2].port == 11211);
2447   assert(server_pool[2].weight == 200);
2448   assert(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2449   assert(server_pool[7].port == 11211);
2450   assert(server_pool[7].weight == 100);
2451
2452   memc->hosts[2].next_retry = time(NULL) + 15;
2453   memc->next_distribution_rebuild= time(NULL) - 1;
2454
2455   for (int x= 0; x < 99; x++)
2456   {
2457     uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2458     assert(server_idx != 2);
2459   }
2460
2461   /* and re-added when it's back. */
2462   memc->hosts[2].next_retry = time(NULL) - 1;
2463   memc->next_distribution_rebuild= time(NULL) - 1;
2464   run_distribution(memc);
2465   for (int x= 0; x < 99; x++)
2466   {
2467     uint32_t server_idx = memcached_generate_hash(memc, test_cases[x].key, strlen(test_cases[x].key));
2468     char *hostname = memc->hosts[server_idx].hostname;
2469     assert(strcmp(hostname, test_cases[x].server) == 0);
2470   }
2471
2472   memcached_server_list_free(server_pool);
2473   memcached_free(memc);
2474
2475   return TEST_SUCCESS;
2476 }
2477
2478 static test_return  result_static(memcached_st *memc)
2479 {
2480   memcached_result_st result;
2481   memcached_result_st *result_ptr;
2482
2483   result_ptr= memcached_result_create(memc, &result);
2484   assert(result.is_allocated == false);
2485   assert(result_ptr);
2486   memcached_result_free(&result);
2487
2488   return 0;
2489 }
2490
2491 static test_return  result_alloc(memcached_st *memc)
2492 {
2493   memcached_result_st *result;
2494
2495   result= memcached_result_create(memc, NULL);
2496   assert(result);
2497   memcached_result_free(result);
2498
2499   return 0;
2500 }
2501
2502 static test_return  string_static_null(memcached_st *memc)
2503 {
2504   memcached_string_st string;
2505   memcached_string_st *string_ptr;
2506
2507   string_ptr= memcached_string_create(memc, &string, 0);
2508   assert(string.is_allocated == false);
2509   assert(string_ptr);
2510   memcached_string_free(&string);
2511
2512   return 0;
2513 }
2514
2515 static test_return  string_alloc_null(memcached_st *memc)
2516 {
2517   memcached_string_st *string;
2518
2519   string= memcached_string_create(memc, NULL, 0);
2520   assert(string);
2521   memcached_string_free(string);
2522
2523   return 0;
2524 }
2525
2526 static test_return  string_alloc_with_size(memcached_st *memc)
2527 {
2528   memcached_string_st *string;
2529
2530   string= memcached_string_create(memc, NULL, 1024);
2531   assert(string);
2532   memcached_string_free(string);
2533
2534   return 0;
2535 }
2536
2537 static test_return  string_alloc_with_size_toobig(memcached_st *memc)
2538 {
2539   memcached_string_st *string;
2540
2541   string= memcached_string_create(memc, NULL, INT64_MAX);
2542   assert(string == NULL);
2543
2544   return 0;
2545 }
2546
2547 static test_return  string_alloc_append(memcached_st *memc)
2548 {
2549   unsigned int x;
2550   char buffer[SMALL_STRING_LEN];
2551   memcached_string_st *string;
2552
2553   /* Ring the bell! */
2554   memset(buffer, 6, SMALL_STRING_LEN);
2555
2556   string= memcached_string_create(memc, NULL, 100);
2557   assert(string);
2558
2559   for (x= 0; x < 1024; x++)
2560   {
2561     memcached_return rc;
2562     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2563     assert(rc == MEMCACHED_SUCCESS);
2564   }
2565   memcached_string_free(string);
2566
2567   return 0;
2568 }
2569
2570 static test_return  string_alloc_append_toobig(memcached_st *memc)
2571 {
2572   memcached_return rc;
2573   unsigned int x;
2574   char buffer[SMALL_STRING_LEN];
2575   memcached_string_st *string;
2576
2577   /* Ring the bell! */
2578   memset(buffer, 6, SMALL_STRING_LEN);
2579
2580   string= memcached_string_create(memc, NULL, 100);
2581   assert(string);
2582
2583   for (x= 0; x < 1024; x++)
2584   {
2585     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
2586     assert(rc == MEMCACHED_SUCCESS);
2587   }
2588   rc= memcached_string_append(string, buffer, INT64_MAX);
2589   assert(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
2590   memcached_string_free(string);
2591
2592   return 0;
2593 }
2594
2595 static test_return  cleanup_pairs(memcached_st *memc __attribute__((unused)))
2596 {
2597   pairs_free(global_pairs);
2598
2599   return 0;
2600 }
2601
2602 static test_return  generate_pairs(memcached_st *memc __attribute__((unused)))
2603 {
2604   unsigned long long x;
2605   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
2606   global_count= GLOBAL_COUNT;
2607
2608   for (x= 0; x < global_count; x++)
2609   {
2610     global_keys[x]= global_pairs[x].key;
2611     global_keys_length[x]=  global_pairs[x].key_length;
2612   }
2613
2614   return 0;
2615 }
2616
2617 static test_return  generate_large_pairs(memcached_st *memc __attribute__((unused)))
2618 {
2619   unsigned long long x;
2620   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
2621   global_count= GLOBAL2_COUNT;
2622
2623   for (x= 0; x < global_count; x++)
2624   {
2625     global_keys[x]= global_pairs[x].key;
2626     global_keys_length[x]=  global_pairs[x].key_length;
2627   }
2628
2629   return 0;
2630 }
2631
2632 static test_return  generate_data(memcached_st *memc)
2633 {
2634   execute_set(memc, global_pairs, global_count);
2635
2636   return 0;
2637 }
2638
2639 static test_return  generate_data_with_stats(memcached_st *memc)
2640 {
2641   memcached_stat_st *stat_p;
2642   memcached_return rc;
2643   uint32_t host_index= 0;
2644   execute_set(memc, global_pairs, global_count);
2645
2646   //TODO: hosts used size stats
2647   stat_p= memcached_stat(memc, NULL, &rc);
2648   assert(stat_p);
2649
2650   for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
2651   {
2652       printf("\nserver %u|%s|%u bytes: %llu\n", host_index, (memc->hosts)[host_index].hostname, (memc->hosts)[host_index].port, (unsigned long long)(stat_p + host_index)->bytes);
2653   }
2654
2655   memcached_stat_free(NULL, stat_p);
2656
2657   return 0;
2658 }
2659 static test_return  generate_buffer_data(memcached_st *memc)
2660 {
2661   int latch= 0;
2662
2663   latch= 1;
2664   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2665   generate_data(memc);
2666
2667   return 0;
2668 }
2669
2670 static test_return  get_read_count(memcached_st *memc)
2671 {
2672   unsigned int x;
2673   memcached_return rc;
2674   memcached_st *clone;
2675
2676   clone= memcached_clone(NULL, memc);
2677   assert(clone);
2678
2679   memcached_server_add_with_weight(clone, "localhost", 6666, 0);
2680
2681   {
2682     char *return_value;
2683     size_t return_value_length;
2684     uint32_t flags;
2685     uint32_t count;
2686
2687     for (x= count= 0; x < global_count; x++)
2688     {
2689       return_value= memcached_get(clone, global_keys[x], global_keys_length[x],
2690                                   &return_value_length, &flags, &rc);
2691       if (rc == MEMCACHED_SUCCESS)
2692       {
2693         count++;
2694         if (return_value)
2695           free(return_value);
2696       }
2697     }
2698     fprintf(stderr, "\t%u -> %u", global_count, count);
2699   }
2700
2701   memcached_free(clone);
2702
2703   return 0;
2704 }
2705
2706 static test_return  get_read(memcached_st *memc)
2707 {
2708   unsigned int x;
2709   memcached_return rc;
2710
2711   {
2712     char *return_value;
2713     size_t return_value_length;
2714     uint32_t flags;
2715
2716     for (x= 0; x < global_count; x++)
2717     {
2718       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
2719                                   &return_value_length, &flags, &rc);
2720       /*
2721       assert(return_value);
2722       assert(rc == MEMCACHED_SUCCESS);
2723     */
2724       if (rc == MEMCACHED_SUCCESS && return_value)
2725         free(return_value);
2726     }
2727   }
2728
2729   return 0;
2730 }
2731
2732 static test_return  mget_read(memcached_st *memc)
2733 {
2734   memcached_return rc;
2735
2736   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2737   assert(rc == MEMCACHED_SUCCESS);
2738   /* Turn this into a help function */
2739   {
2740     char return_key[MEMCACHED_MAX_KEY];
2741     size_t return_key_length;
2742     char *return_value;
2743     size_t return_value_length;
2744     uint32_t flags;
2745
2746     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2747                                           &return_value_length, &flags, &rc)))
2748     {
2749       assert(return_value);
2750       assert(rc == MEMCACHED_SUCCESS);
2751       free(return_value);
2752     }
2753   }
2754
2755   return 0;
2756 }
2757
2758 static test_return  mget_read_result(memcached_st *memc)
2759 {
2760   memcached_return rc;
2761
2762   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2763   assert(rc == MEMCACHED_SUCCESS);
2764   /* Turn this into a help function */
2765   {
2766     memcached_result_st results_obj;
2767     memcached_result_st *results;
2768
2769     results= memcached_result_create(memc, &results_obj);
2770
2771     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
2772     {
2773       assert(results);
2774       assert(rc == MEMCACHED_SUCCESS);
2775     }
2776
2777     memcached_result_free(&results_obj);
2778   }
2779
2780   return 0;
2781 }
2782
2783 static test_return  mget_read_function(memcached_st *memc)
2784 {
2785   memcached_return rc;
2786   unsigned int counter;
2787   memcached_execute_function callbacks[1];
2788
2789   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
2790   assert(rc == MEMCACHED_SUCCESS);
2791
2792   callbacks[0]= &callback_counter;
2793   counter= 0;
2794   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
2795
2796   return 0;
2797 }
2798
2799 static test_return  delete_generate(memcached_st *memc)
2800 {
2801   unsigned int x;
2802
2803   for (x= 0; x < global_count; x++)
2804   {
2805     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2806   }
2807
2808   return 0;
2809 }
2810
2811 static test_return  delete_buffer_generate(memcached_st *memc)
2812 {
2813   int latch= 0;
2814   unsigned int x;
2815
2816   latch= 1;
2817   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
2818
2819   for (x= 0; x < global_count; x++)
2820   {
2821     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
2822   }
2823
2824   return 0;
2825 }
2826
2827 static test_return  free_data(memcached_st *memc __attribute__((unused)))
2828 {
2829   pairs_free(global_pairs);
2830
2831   return 0;
2832 }
2833
2834 static test_return  add_host_test1(memcached_st *memc)
2835 {
2836   unsigned int x;
2837   memcached_return rc;
2838   char servername[]= "0.example.com";
2839   memcached_server_st *servers;
2840
2841   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
2842   assert(servers);
2843   assert(1 == memcached_server_list_count(servers));
2844
2845   for (x= 2; x < 20; x++)
2846   {
2847     char buffer[SMALL_STRING_LEN];
2848
2849     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
2850     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
2851                                      &rc);
2852     assert(rc == MEMCACHED_SUCCESS);
2853     assert(x == memcached_server_list_count(servers));
2854   }
2855
2856   rc= memcached_server_push(memc, servers);
2857   assert(rc == MEMCACHED_SUCCESS);
2858   rc= memcached_server_push(memc, servers);
2859   assert(rc == MEMCACHED_SUCCESS);
2860
2861   memcached_server_list_free(servers);
2862
2863   return 0;
2864 }
2865
2866 static memcached_return  pre_nonblock(memcached_st *memc)
2867 {
2868   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2869
2870   return MEMCACHED_SUCCESS;
2871 }
2872
2873 static memcached_return  pre_nonblock_binary(memcached_st *memc)
2874 {
2875   memcached_return rc= MEMCACHED_FAILURE;
2876   memcached_st *clone;
2877
2878   clone= memcached_clone(NULL, memc);
2879   assert(clone);
2880   // The memcached_version needs to be done on a clone, because the server
2881   // will not toggle protocol on an connection.
2882   memcached_version(clone);
2883
2884   if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2)
2885   {
2886     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2887     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
2888     assert(rc == MEMCACHED_SUCCESS);
2889     assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
2890   }
2891
2892   memcached_free(clone);
2893   return rc;
2894 }
2895
2896 static memcached_return  pre_murmur(memcached_st *memc)
2897 {
2898   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
2899
2900   return MEMCACHED_SUCCESS;
2901 }
2902
2903 static memcached_return pre_jenkins(memcached_st *memc)
2904 {
2905   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
2906
2907   return MEMCACHED_SUCCESS;
2908 }
2909
2910
2911 static memcached_return  pre_md5(memcached_st *memc)
2912 {
2913   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
2914
2915   return MEMCACHED_SUCCESS;
2916 }
2917
2918 static memcached_return  pre_crc(memcached_st *memc)
2919 {
2920   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
2921
2922   return MEMCACHED_SUCCESS;
2923 }
2924
2925 static memcached_return  pre_hsieh(memcached_st *memc)
2926 {
2927 #ifdef HAVE_HSIEH_HASH
2928   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
2929   return MEMCACHED_SUCCESS;
2930 #else
2931   return MEMCACHED_FAILURE;
2932 #endif
2933 }
2934
2935 static memcached_return  pre_hash_fnv1_64(memcached_st *memc)
2936 {
2937   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_64);
2938
2939   return MEMCACHED_SUCCESS;
2940 }
2941
2942 static memcached_return  pre_hash_fnv1a_64(memcached_st *memc)
2943 {
2944   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
2945
2946   return MEMCACHED_SUCCESS;
2947 }
2948
2949 static memcached_return  pre_hash_fnv1_32(memcached_st *memc)
2950 {
2951   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
2952
2953   return MEMCACHED_SUCCESS;
2954 }
2955
2956 static memcached_return  pre_hash_fnv1a_32(memcached_st *memc)
2957 {
2958   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
2959
2960   return MEMCACHED_SUCCESS;
2961 }
2962
2963 static memcached_return  pre_behavior_ketama(memcached_st *memc)
2964 {
2965   memcached_return rc;
2966   uint64_t value;
2967
2968   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
2969   assert(rc == MEMCACHED_SUCCESS);
2970
2971   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
2972   assert(value == 1);
2973
2974   return MEMCACHED_SUCCESS;
2975 }
2976
2977 static memcached_return  pre_behavior_ketama_weighted(memcached_st *memc)
2978 {
2979   memcached_return rc;
2980   uint64_t value;
2981
2982   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2983   assert(rc == MEMCACHED_SUCCESS);
2984
2985   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2986   assert(value == 1);
2987
2988   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2989   assert(rc == MEMCACHED_SUCCESS);
2990
2991   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2992   assert(value == MEMCACHED_HASH_MD5);
2993   return MEMCACHED_SUCCESS;
2994 }
2995
2996 static memcached_return  pre_binary(memcached_st *memc)
2997 {
2998   memcached_return rc= MEMCACHED_FAILURE;
2999   memcached_st *clone;
3000
3001   clone= memcached_clone(NULL, memc);
3002   assert(clone);
3003   // The memcached_version needs to be done on a clone, because the server
3004   // will not toggle protocol on an connection.
3005   memcached_version(clone);
3006
3007   if (clone->hosts[0].major_version >= 1 && clone->hosts[0].minor_version > 2)
3008   {
3009     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3010     assert(rc == MEMCACHED_SUCCESS);
3011     assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3012   }
3013
3014   memcached_free(clone);
3015   return rc;
3016 }
3017
3018 static void my_free(memcached_st *ptr __attribute__((unused)), void *mem)
3019 {
3020   free(mem);
3021 }
3022
3023 static void *my_malloc(memcached_st *ptr __attribute__((unused)), const size_t size)
3024 {
3025   return malloc(size);
3026 }
3027
3028 static void *my_realloc(memcached_st *ptr __attribute__((unused)), void *mem, const size_t size)
3029 {
3030   return realloc(mem, size);
3031 }
3032
3033 static memcached_return set_prefix(memcached_st *memc)
3034 {
3035   memcached_return rc;
3036   const char *key= "mine";
3037   char *value;
3038
3039   /* Make sure be default none exists */
3040   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3041   assert(rc == MEMCACHED_FAILURE);
3042
3043   /* Test a clean set */
3044   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3045   assert(rc == MEMCACHED_SUCCESS);
3046
3047   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3048   assert(memcmp(value, key, 4) == 0);
3049   assert(rc == MEMCACHED_SUCCESS);
3050
3051   /* Test that we can turn it off */
3052   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3053   assert(rc == MEMCACHED_SUCCESS);
3054
3055   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3056   assert(rc == MEMCACHED_FAILURE);
3057
3058   /* Now setup for main test */
3059   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3060   assert(rc == MEMCACHED_SUCCESS);
3061
3062   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3063   assert(rc == MEMCACHED_SUCCESS);
3064   assert(memcmp(value, key, 4) == 0);
3065
3066   /* Set to Zero, and then Set to something too large */
3067   {
3068     char *long_key;
3069     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3070     assert(rc == MEMCACHED_SUCCESS);
3071
3072     value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3073     assert(rc == MEMCACHED_FAILURE);
3074     assert(value == NULL);
3075
3076     /* Test a long key for failure */
3077     /* TODO, extend test to determine based on setting, what result should be */
3078     long_key= "Thisismorethentheallottednumberofcharacters";
3079     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3080     //assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3081     assert(rc == MEMCACHED_SUCCESS);
3082
3083     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3084     long_key= "This is more then the allotted number of characters";
3085     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3086     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3087
3088     /* Test for a bad prefix, but with a short key */
3089     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3090     assert(rc == MEMCACHED_SUCCESS);
3091
3092     long_key= "dog cat";
3093     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3094     assert(rc == MEMCACHED_BAD_KEY_PROVIDED);
3095   }
3096
3097   return MEMCACHED_SUCCESS;
3098 }
3099
3100 static memcached_return  set_memory_alloc(memcached_st *memc)
3101 {
3102   {
3103     memcached_malloc_function test_ptr;
3104     memcached_return rc;
3105
3106     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, (void*)&my_malloc);
3107     assert(rc == MEMCACHED_SUCCESS);
3108     test_ptr= (memcached_malloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3109     assert(rc == MEMCACHED_SUCCESS);
3110     assert(test_ptr == my_malloc);
3111   }
3112
3113   {
3114     memcached_realloc_function test_ptr;
3115     memcached_return rc;
3116
3117     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, (void*)&my_realloc);
3118     assert(rc == MEMCACHED_SUCCESS);
3119     test_ptr= (memcached_realloc_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3120     assert(rc == MEMCACHED_SUCCESS);
3121     assert(test_ptr == my_realloc);
3122   }
3123
3124   {
3125     memcached_free_function test_ptr;
3126     memcached_return rc;
3127
3128     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, (void*)my_free);
3129     assert(rc == MEMCACHED_SUCCESS);
3130     test_ptr= (memcached_free_function)memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3131     assert(rc == MEMCACHED_SUCCESS);
3132     assert(test_ptr == my_free);
3133   }
3134
3135   return MEMCACHED_SUCCESS;
3136 }
3137
3138 static memcached_return  enable_consistent(memcached_st *memc)
3139 {
3140   memcached_server_distribution value= MEMCACHED_DISTRIBUTION_CONSISTENT;
3141   memcached_hash hash;
3142   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
3143   if (pre_hsieh(memc) != MEMCACHED_SUCCESS)
3144     return MEMCACHED_FAILURE;
3145
3146   value= (memcached_server_distribution)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
3147   assert(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
3148
3149   hash= (memcached_hash)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
3150   assert(hash == MEMCACHED_HASH_HSIEH);
3151
3152
3153   return MEMCACHED_SUCCESS;
3154 }
3155
3156 static memcached_return  enable_cas(memcached_st *memc)
3157 {
3158   unsigned int set= 1;
3159
3160   memcached_version(memc);
3161
3162   if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3163       || memc->hosts[0].minor_version > 2)
3164   {
3165     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
3166
3167     return MEMCACHED_SUCCESS;
3168   }
3169
3170   return MEMCACHED_FAILURE;
3171 }
3172
3173 static memcached_return  check_for_1_2_3(memcached_st *memc)
3174 {
3175   memcached_version(memc);
3176
3177   if ((memc->hosts[0].major_version >= 1 && (memc->hosts[0].minor_version == 2 && memc->hosts[0].micro_version >= 4))
3178       || memc->hosts[0].minor_version > 2)
3179     return MEMCACHED_SUCCESS;
3180
3181   return MEMCACHED_FAILURE;
3182 }
3183
3184 static memcached_return  pre_unix_socket(memcached_st *memc)
3185 {
3186   memcached_return rc;
3187   struct stat buf;
3188
3189   memcached_server_list_free(memc->hosts);
3190   memc->hosts= NULL;
3191   memc->number_of_hosts= 0;
3192
3193   if (stat("/tmp/memcached.socket", &buf))
3194     return MEMCACHED_FAILURE;
3195
3196   rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
3197
3198   return rc;
3199 }
3200
3201 static memcached_return  pre_nodelay(memcached_st *memc)
3202 {
3203   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3204   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
3205
3206   return MEMCACHED_SUCCESS;
3207 }
3208
3209 static memcached_return  pre_settimer(memcached_st *memc)
3210 {
3211   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
3212   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
3213
3214   return MEMCACHED_SUCCESS;
3215 }
3216
3217 static memcached_return  poll_timeout(memcached_st *memc)
3218 {
3219   int32_t timeout;
3220
3221   timeout= 100;
3222
3223   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
3224
3225   timeout= (int32_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
3226
3227   assert(timeout == 100);
3228
3229   return MEMCACHED_SUCCESS;
3230 }
3231
3232 static test_return noreply_test(memcached_st *memc)
3233 {
3234   memcached_return ret;
3235   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
3236   assert(ret == MEMCACHED_SUCCESS);
3237   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3238   assert(ret == MEMCACHED_SUCCESS);
3239   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
3240   assert(ret == MEMCACHED_SUCCESS);
3241   assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
3242   assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
3243   assert(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
3244
3245   for (int count=0; count < 5; ++count)
3246   {
3247     for (int x=0; x < 100; ++x)
3248     {
3249       char key[10];
3250       size_t len=sprintf(key, "%d", x);
3251       switch (count)
3252       {
3253       case 0:
3254         ret=memcached_add(memc, key, len, key, len, 0, 0);
3255         break;
3256       case 1:
3257         ret=memcached_replace(memc, key, len, key, len, 0, 0);
3258         break;
3259       case 2:
3260         ret=memcached_set(memc, key, len, key, len, 0, 0);
3261         break;
3262       case 3:
3263         ret=memcached_append(memc, key, len, key, len, 0, 0);
3264         break;
3265       case 4:
3266         ret=memcached_prepend(memc, key, len, key, len, 0, 0);
3267         break;
3268       }
3269       assert(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
3270     }
3271
3272     /*
3273     ** NOTE: Don't ever do this in your code! this is not a supported use of the
3274     ** API and is _ONLY_ done this way to verify that the library works the
3275     ** way it is supposed to do!!!!
3276     */
3277     int no_msg=0;
3278     for (int x=0; x < memc->number_of_hosts; ++x)
3279       no_msg+=memc->hosts[x].cursor_active;
3280
3281     assert(no_msg == 0);
3282     assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3283
3284     /*
3285      ** Now validate that all items was set properly!
3286      */
3287     for (int x=0; x < 100; ++x)
3288     {
3289       char key[10];
3290       size_t len=sprintf(key, "%d", x);
3291       size_t length;
3292       uint32_t flags;
3293       char* value=memcached_get(memc, key, strlen(key),
3294                                 &length, &flags, &ret);
3295       assert(ret == MEMCACHED_SUCCESS && value != NULL);
3296       switch (count)
3297       {
3298       case 0: /* FALLTHROUGH */
3299       case 1: /* FALLTHROUGH */
3300       case 2:
3301         assert(strncmp(value, key, len) == 0);
3302         assert(len == length);
3303         break;
3304       case 3:
3305         assert(length == len * 2);
3306         break;
3307       case 4:
3308         assert(length == len * 3);
3309         break;
3310       }
3311       free(value);
3312     }
3313   }
3314
3315   /* Try setting an illegal cas value (should not return an error to
3316    * the caller (because we don't expect a return message from the server)
3317    */
3318   char* keys[]= {"0"};
3319   size_t lengths[]= {1};
3320   size_t length;
3321   uint32_t flags;
3322   memcached_result_st results_obj;
3323   memcached_result_st *results;
3324   ret=memcached_mget(memc, keys, lengths, 1);
3325   assert(ret == MEMCACHED_SUCCESS);
3326
3327   results=memcached_result_create(memc, &results_obj);
3328   assert(results);
3329   results=memcached_fetch_result(memc, &results_obj, &ret);
3330   assert(results);
3331   assert(ret == MEMCACHED_SUCCESS);
3332   uint64_t cas= memcached_result_cas(results);
3333   memcached_result_free(&results_obj);
3334
3335   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3336   assert(ret == MEMCACHED_SUCCESS);
3337
3338   /*
3339    * The item will have a new cas value, so try to set it again with the old
3340    * value. This should fail!
3341    */
3342   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
3343   assert(ret == MEMCACHED_SUCCESS);
3344   assert(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3345   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
3346   assert(ret == MEMCACHED_SUCCESS && value != NULL);
3347   free(value);
3348
3349   return TEST_SUCCESS;
3350 }
3351
3352 static test_return analyzer_test(memcached_st *memc)
3353 {
3354   memcached_return rc;
3355   memcached_stat_st *stat;
3356   memcached_analysis_st *report;
3357
3358   stat= memcached_stat(memc, NULL, &rc);
3359   assert(rc == MEMCACHED_SUCCESS);
3360   assert(stat);
3361
3362   report= memcached_analyze(memc, stat, &rc);
3363   assert(rc == MEMCACHED_SUCCESS);
3364   assert(report);
3365
3366   free(report);
3367   memcached_stat_free(NULL, stat);
3368
3369   return TEST_SUCCESS;
3370 }
3371
3372 static void increment_request_id(uint16_t *id)
3373 {
3374   (*id)++;
3375   if ((*id & UDP_REQUEST_ID_THREAD_MASK) != 0)
3376     *id= 0;
3377 }
3378
3379 static uint16_t *get_udp_request_ids(memcached_st *memc)
3380 {
3381   uint16_t *ids= malloc(sizeof(uint16_t) * memc->number_of_hosts);
3382   assert(ids != NULL);
3383   unsigned int x;
3384   for (x= 0; x < memc->number_of_hosts; x++)
3385     ids[x]= get_udp_datagram_request_id((struct udp_datagram_header_st *) memc->hosts[x].write_buffer);
3386
3387   return ids;
3388 }
3389
3390 static test_return post_udp_op_check(memcached_st *memc, uint16_t *expected_req_ids)
3391 {
3392   unsigned int x;
3393   memcached_server_st *cur_server = memc->hosts;
3394   uint16_t *cur_req_ids = get_udp_request_ids(memc);
3395   for (x= 0; x < memc->number_of_hosts; x++)
3396   {
3397     assert(cur_server[x].cursor_active == 0);
3398     assert(cur_req_ids[x] == expected_req_ids[x]);
3399   }
3400   free(expected_req_ids);
3401   free(cur_req_ids);
3402   return TEST_SUCCESS;
3403 }
3404
3405 /*
3406 ** There is a little bit of a hack here, instead of removing
3407 ** the servers, I just set num host to 0 and them add then new udp servers
3408 **/
3409 static memcached_return init_udp(memcached_st *memc)
3410 {
3411   memcached_version(memc);
3412   /* For the time being, only support udp test for >= 1.2.6 && < 1.3 */
3413   if (memc->hosts[0].major_version != 1 || memc->hosts[0].minor_version != 2
3414           || memc->hosts[0].micro_version < 6)
3415     return MEMCACHED_FAILURE;
3416
3417   uint32_t num_hosts= memc->number_of_hosts;
3418   unsigned int x= 0;
3419   memcached_server_st servers[num_hosts];
3420   memcpy(servers, memc->hosts, sizeof(memcached_server_st) * num_hosts);
3421   for (x= 0; x < num_hosts; x++)
3422     memcached_server_free(&memc->hosts[x]);
3423   memc->number_of_hosts= 0;
3424   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1);
3425   for (x= 0; x < num_hosts; x++)
3426   {
3427     assert(memcached_server_add_udp(memc, servers[x].hostname, servers[x].port) == MEMCACHED_SUCCESS);
3428     assert(memc->hosts[x].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3429   }
3430   return MEMCACHED_SUCCESS;
3431 }
3432
3433 static memcached_return binary_init_udp(memcached_st *memc)
3434 {
3435   pre_binary(memc);
3436   return init_udp(memc);
3437 }
3438
3439 /* Make sure that I cant add a tcp server to a udp client */
3440 static test_return add_tcp_server_udp_client_test(memcached_st *memc)
3441 {
3442   memcached_server_st server;
3443   memcached_server_clone(&server, &memc->hosts[0]);
3444   assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3445   assert(memcached_server_add(memc, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3446   return TEST_SUCCESS;
3447 }
3448
3449 /* Make sure that I cant add a udp server to a tcp client */
3450 static test_return add_udp_server_tcp_client_test(memcached_st *memc)
3451 {
3452   memcached_server_st server;
3453   memcached_server_clone(&server, &memc->hosts[0]);
3454   assert(memcached_server_remove(&(memc->hosts[0])) == MEMCACHED_SUCCESS);
3455
3456   memcached_st tcp_client;
3457   memcached_create(&tcp_client);
3458   assert(memcached_server_add_udp(&tcp_client, server.hostname, server.port) == MEMCACHED_INVALID_HOST_PROTOCOL);
3459   return TEST_SUCCESS;
3460 }
3461
3462 static test_return set_udp_behavior_test(memcached_st *memc)
3463 {
3464
3465   memcached_quit(memc);
3466   memc->number_of_hosts= 0;
3467   run_distribution(memc);
3468   assert(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP, 1) == MEMCACHED_SUCCESS);
3469   assert(memc->flags & MEM_USE_UDP);
3470   assert(memc->flags & MEM_NOREPLY);;
3471
3472   assert(memc->number_of_hosts == 0);
3473
3474   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_USE_UDP,0);
3475   assert(!(memc->flags & MEM_USE_UDP));
3476   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY,0);
3477   assert(!(memc->flags & MEM_NOREPLY));
3478   return TEST_SUCCESS;
3479 }
3480
3481 static test_return udp_set_test(memcached_st *memc)
3482 {
3483   unsigned int x= 0;
3484   unsigned int num_iters= 1025; //request id rolls over at 1024
3485   for (x= 0; x < num_iters;x++)
3486   {
3487     memcached_return rc;
3488     char *key= "foo";
3489     char *value= "when we sanitize";
3490     uint16_t *expected_ids= get_udp_request_ids(memc);
3491     unsigned int server_key= memcached_generate_hash(memc,key,strlen(key));
3492     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
3493     rc= memcached_set(memc, key, strlen(key),
3494                       value, strlen(value),
3495                       (time_t)0, (uint32_t)0);
3496     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
3497     /** NB, the check below assumes that if new write_ptr is less than
3498      *  the original write_ptr that we have flushed. For large payloads, this
3499      *  maybe an invalid assumption, but for the small payload we have it is OK
3500      */
3501     if (rc == MEMCACHED_SUCCESS ||
3502             memc->hosts[server_key].write_buffer_offset < init_offset)
3503       increment_request_id(&expected_ids[server_key]);
3504
3505     if (rc == MEMCACHED_SUCCESS)
3506     {
3507       assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3508     }
3509     else
3510     {
3511       assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
3512       assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
3513     }
3514     assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
3515   }
3516   return TEST_SUCCESS;
3517 }
3518
3519 static test_return udp_buffered_set_test(memcached_st *memc)
3520 {
3521   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3522   return udp_set_test(memc);
3523 }
3524
3525 static test_return udp_set_too_big_test(memcached_st *memc)
3526 {
3527   memcached_return rc;
3528   char *key= "bar";
3529   char value[MAX_UDP_DATAGRAM_LENGTH];
3530   uint16_t *expected_ids= get_udp_request_ids(memc);
3531   rc= memcached_set(memc, key, strlen(key),
3532                     value, MAX_UDP_DATAGRAM_LENGTH,
3533                     (time_t)0, (uint32_t)0);
3534   assert(rc == MEMCACHED_WRITE_FAILURE);
3535   return post_udp_op_check(memc,expected_ids);
3536 }
3537
3538 test_return udp_delete_test(memcached_st *memc)
3539 {
3540   unsigned int x= 0;
3541   unsigned int num_iters= 1025; //request id rolls over at 1024
3542   for (x= 0; x < num_iters;x++)
3543   {
3544     memcached_return rc;
3545     char *key= "foo";
3546     uint16_t *expected_ids=get_udp_request_ids(memc);
3547     unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3548     size_t init_offset= memc->hosts[server_key].write_buffer_offset;
3549     rc= memcached_delete(memc, key, strlen(key), 0);
3550     assert(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
3551     if (rc == MEMCACHED_SUCCESS || memc->hosts[server_key].write_buffer_offset < init_offset)
3552       increment_request_id(&expected_ids[server_key]);
3553     if (rc == MEMCACHED_SUCCESS)
3554       assert(memc->hosts[server_key].write_buffer_offset == UDP_DATAGRAM_HEADER_LENGTH);
3555     else
3556     {
3557       assert(memc->hosts[server_key].write_buffer_offset != UDP_DATAGRAM_HEADER_LENGTH);
3558       assert(memc->hosts[server_key].write_buffer_offset <= MAX_UDP_DATAGRAM_LENGTH);
3559     }
3560     assert(post_udp_op_check(memc,expected_ids) == TEST_SUCCESS);
3561   }
3562   return TEST_SUCCESS;
3563 }
3564
3565 static test_return udp_buffered_delete_test(memcached_st *memc)
3566 {
3567   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
3568   return udp_delete_test(memc);
3569 }
3570
3571 test_return udp_verbosity_test(memcached_st *memc)
3572 {
3573   memcached_return rc;
3574   uint16_t *expected_ids= get_udp_request_ids(memc);
3575   unsigned int x;
3576   for (x= 0; x < memc->number_of_hosts;x++)
3577     increment_request_id(&expected_ids[x]);
3578
3579   rc= memcached_verbosity(memc,3);
3580   assert(rc == MEMCACHED_SUCCESS);
3581   return post_udp_op_check(memc,expected_ids);
3582 }
3583
3584 test_return udp_quit_test(memcached_st *memc)
3585 {
3586   uint16_t *expected_ids= get_udp_request_ids(memc);
3587   memcached_quit(memc);
3588   return post_udp_op_check(memc, expected_ids);
3589 }
3590
3591 test_return udp_flush_test(memcached_st *memc)
3592 {
3593   memcached_return rc;
3594   uint16_t *expected_ids= get_udp_request_ids(memc);
3595   unsigned int x;
3596   for (x= 0; x < memc->number_of_hosts;x++)
3597     increment_request_id(&expected_ids[x]);
3598
3599   rc= memcached_flush(memc,0);
3600   assert(rc == MEMCACHED_SUCCESS);
3601   return post_udp_op_check(memc,expected_ids);
3602 }
3603
3604 test_return udp_incr_test(memcached_st *memc)
3605 {
3606   memcached_return rc;
3607   char *key= "incr";
3608   char *value= "1";
3609   rc= memcached_set(memc, key, strlen(key),
3610                     value, strlen(value),
3611                     (time_t)0, (uint32_t)0);
3612
3613   assert(rc == MEMCACHED_SUCCESS);
3614   uint16_t *expected_ids= get_udp_request_ids(memc);
3615   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3616   increment_request_id(&expected_ids[server_key]);
3617   uint64_t newvalue;
3618   rc= memcached_increment(memc, key, strlen(key), 1, &newvalue);
3619   assert(rc == MEMCACHED_SUCCESS);
3620   return post_udp_op_check(memc, expected_ids);
3621 }
3622
3623 test_return udp_decr_test(memcached_st *memc)
3624 {
3625   memcached_return rc;
3626   char *key= "decr";
3627   char *value= "1";
3628   rc= memcached_set(memc, key, strlen(key),
3629                     value, strlen(value),
3630                     (time_t)0, (uint32_t)0);
3631
3632   assert(rc == MEMCACHED_SUCCESS);
3633   uint16_t *expected_ids= get_udp_request_ids(memc);
3634   unsigned int server_key= memcached_generate_hash(memc, key, strlen(key));
3635   increment_request_id(&expected_ids[server_key]);
3636   uint64_t newvalue;
3637   rc= memcached_decrement(memc, key, strlen(key), 1, &newvalue);
3638   assert(rc == MEMCACHED_SUCCESS);
3639   return post_udp_op_check(memc, expected_ids);
3640 }
3641
3642
3643 test_return udp_stat_test(memcached_st *memc)
3644 {
3645   memcached_stat_st * rv= NULL;
3646   memcached_return rc;
3647   char args[]= "";
3648   uint16_t *expected_ids = get_udp_request_ids(memc);
3649   rv = memcached_stat(memc, args, &rc);
3650   free(rv);
3651   assert(rc == MEMCACHED_NOT_SUPPORTED);
3652   return post_udp_op_check(memc, expected_ids);
3653 }
3654
3655 test_return udp_version_test(memcached_st *memc)
3656 {
3657   memcached_return rc;
3658   uint16_t *expected_ids = get_udp_request_ids(memc);
3659   rc = memcached_version(memc);
3660   assert(rc == MEMCACHED_NOT_SUPPORTED);
3661   return post_udp_op_check(memc, expected_ids);
3662 }
3663
3664 test_return udp_get_test(memcached_st *memc)
3665 {
3666   memcached_return rc;
3667   char *key= "foo";
3668   size_t vlen;
3669   uint16_t *expected_ids = get_udp_request_ids(memc);
3670   char *val= memcached_get(memc, key, strlen(key), &vlen, (uint32_t)0, &rc);
3671   assert(rc == MEMCACHED_NOT_SUPPORTED);
3672   assert(val == NULL);
3673   return post_udp_op_check(memc, expected_ids);
3674 }
3675
3676 test_return udp_mixed_io_test(memcached_st *memc)
3677 {
3678   test_st current_op;
3679   test_st mixed_io_ops [] ={
3680     {"udp_set_test", 0, udp_set_test},
3681     {"udp_set_too_big_test", 0, udp_set_too_big_test},
3682     {"udp_delete_test", 0, udp_delete_test},
3683     {"udp_verbosity_test", 0, udp_verbosity_test},
3684     {"udp_quit_test", 0, udp_quit_test},
3685     {"udp_flush_test", 0, udp_flush_test},
3686     {"udp_incr_test", 0, udp_incr_test},
3687     {"udp_decr_test", 0, udp_decr_test},
3688     {"udp_version_test", 0, udp_version_test}
3689   };
3690   unsigned int x= 0;
3691   for (x= 0; x < 500; x++)
3692   {
3693     current_op= mixed_io_ops[random() % 9];
3694     assert(current_op.function(memc) == TEST_SUCCESS);
3695   }
3696   return TEST_SUCCESS;
3697 }
3698
3699 test_return hsieh_avaibility_test (memcached_st *memc)
3700 {
3701   memcached_return expected_rc= MEMCACHED_FAILURE;
3702 #ifdef HAVE_HSIEH_HASH
3703   expected_rc= MEMCACHED_SUCCESS;
3704 #endif
3705   memcached_return rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
3706                                             (uint64_t)MEMCACHED_HASH_HSIEH);
3707   assert(rc == expected_rc);
3708   return TEST_SUCCESS;
3709 }
3710
3711 test_st udp_setup_server_tests[] ={
3712   {"set_udp_behavior_test", 0, set_udp_behavior_test},
3713   {"add_tcp_server_udp_client_test", 0, add_tcp_server_udp_client_test},
3714   {"add_udp_server_tcp_client_test", 0, add_udp_server_tcp_client_test},
3715   {0, 0, 0}
3716 };
3717
3718 test_st upd_io_tests[] ={
3719   {"udp_set_test", 0, udp_set_test},
3720   {"udp_buffered_set_test", 0, udp_buffered_set_test},
3721   {"udp_set_too_big_test", 0, udp_set_too_big_test},
3722   {"udp_delete_test", 0, udp_delete_test},
3723   {"udp_buffered_delete_test", 0, udp_buffered_delete_test},
3724   {"udp_verbosity_test", 0, udp_verbosity_test},
3725   {"udp_quit_test", 0, udp_quit_test},
3726   {"udp_flush_test", 0, udp_flush_test},
3727   {"udp_incr_test", 0, udp_incr_test},
3728   {"udp_decr_test", 0, udp_decr_test},
3729   {"udp_stat_test", 0, udp_stat_test},
3730   {"udp_version_test", 0, udp_version_test},
3731   {"udp_get_test", 0, udp_get_test},
3732   {"udp_mixed_io_test", 0, udp_mixed_io_test},
3733   {0, 0, 0}
3734 };
3735
3736 /* Clean the server before beginning testing */
3737 test_st tests[] ={
3738   {"flush", 0, flush_test },
3739   {"init", 0, init_test },
3740   {"allocation", 0, allocation_test },
3741   {"server_list_null_test", 0, server_list_null_test},
3742   {"server_unsort", 0, server_unsort_test},
3743   {"server_sort", 0, server_sort_test},
3744   {"server_sort2", 0, server_sort2_test},
3745   {"clone_test", 0, clone_test },
3746   {"error", 0, error_test },
3747   {"set", 0, set_test },
3748   {"set2", 0, set_test2 },
3749   {"set3", 0, set_test3 },
3750   {"add", 1, add_test },
3751   {"replace", 1, replace_test },
3752   {"delete", 1, delete_test },
3753   {"get", 1, get_test },
3754   {"get2", 0, get_test2 },
3755   {"get3", 0, get_test3 },
3756   {"get4", 0, get_test4 },
3757   {"partial mget", 0, get_test5 },
3758   {"stats_servername", 0, stats_servername_test },
3759   {"increment", 0, increment_test },
3760   {"increment_with_initial", 1, increment_with_initial_test },
3761   {"decrement", 0, decrement_test },
3762   {"decrement_with_initial", 1, decrement_with_initial_test },
3763   {"quit", 0, quit_test },
3764   {"mget", 1, mget_test },
3765   {"mget_result", 1, mget_result_test },
3766   {"mget_result_alloc", 1, mget_result_alloc_test },
3767   {"mget_result_function", 1, mget_result_function },
3768   {"get_stats", 0, get_stats },
3769   {"add_host_test", 0, add_host_test },
3770   {"add_host_test_1", 0, add_host_test1 },
3771   {"get_stats_keys", 0, get_stats_keys },
3772   {"behavior_test", 0, get_stats_keys },
3773   {"callback_test", 0, get_stats_keys },
3774   {"version_string_test", 0, version_string_test},
3775   {"bad_key", 1, bad_key_test },
3776   {"memcached_server_cursor", 1, memcached_server_cursor_test },
3777   {"read_through", 1, read_through },
3778   {"delete_through", 1, delete_through },
3779   {"noreply", 1, noreply_test},
3780   {"analyzer", 1, analyzer_test},
3781   {0, 0, 0}
3782 };
3783
3784 test_st async_tests[] ={
3785   {"add", 1, add_wrapper },
3786   {0, 0, 0}
3787 };
3788
3789 test_st string_tests[] ={
3790   {"string static with null", 0, string_static_null },
3791   {"string alloc with null", 0, string_alloc_null },
3792   {"string alloc with 1K", 0, string_alloc_with_size },
3793   {"string alloc with malloc failure", 0, string_alloc_with_size_toobig },
3794   {"string append", 0, string_alloc_append },
3795   {"string append failure (too big)", 0, string_alloc_append_toobig },
3796   {0, 0, 0}
3797 };
3798
3799 test_st result_tests[] ={
3800   {"result static", 0, result_static},
3801   {"result alloc", 0, result_alloc},
3802   {0, 0, 0}
3803 };
3804
3805 test_st version_1_2_3[] ={
3806   {"append", 0, append_test },
3807   {"prepend", 0, prepend_test },
3808   {"cas", 0, cas_test },
3809   {"cas2", 0, cas2_test },
3810   {"append_binary", 0, append_binary_test },
3811   {0, 0, 0}
3812 };
3813
3814 test_st user_tests[] ={
3815   {"user_supplied_bug1", 0, user_supplied_bug1 },
3816   {"user_supplied_bug2", 0, user_supplied_bug2 },
3817   {"user_supplied_bug3", 0, user_supplied_bug3 },
3818   {"user_supplied_bug4", 0, user_supplied_bug4 },
3819   {"user_supplied_bug5", 1, user_supplied_bug5 },
3820   {"user_supplied_bug6", 1, user_supplied_bug6 },
3821   {"user_supplied_bug7", 1, user_supplied_bug7 },
3822   {"user_supplied_bug8", 1, user_supplied_bug8 },
3823   {"user_supplied_bug9", 1, user_supplied_bug9 },
3824   {"user_supplied_bug10", 1, user_supplied_bug10 },
3825   {"user_supplied_bug11", 1, user_supplied_bug11 },
3826   {"user_supplied_bug12", 1, user_supplied_bug12 },
3827   {"user_supplied_bug13", 1, user_supplied_bug13 },
3828   {"user_supplied_bug14", 1, user_supplied_bug14 },
3829   {"user_supplied_bug15", 1, user_supplied_bug15 },
3830   {"user_supplied_bug16", 1, user_supplied_bug16 },
3831 #ifndef __sun
3832   /*
3833   ** It seems to be something weird with the character sets..
3834   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
3835   ** guess I need to find out how this is supposed to work.. Perhaps I need
3836   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
3837   ** so just disable the code for now...).
3838   */
3839   {"user_supplied_bug17", 1, user_supplied_bug17 },
3840 #endif
3841   {"user_supplied_bug18", 1, user_supplied_bug18 },
3842   {"user_supplied_bug19", 1, user_supplied_bug19 },
3843   {"user_supplied_bug20", 1, user_supplied_bug20 },
3844   {0, 0, 0}
3845 };
3846
3847 test_st generate_tests[] ={
3848   {"generate_pairs", 1, generate_pairs },
3849   {"generate_data", 1, generate_data },
3850   {"get_read", 0, get_read },
3851   {"delete_generate", 0, delete_generate },
3852   {"generate_buffer_data", 1, generate_buffer_data },
3853   {"delete_buffer", 0, delete_buffer_generate},
3854   {"generate_data", 1, generate_data },
3855   {"mget_read", 0, mget_read },
3856   {"mget_read_result", 0, mget_read_result },
3857   {"mget_read_function", 0, mget_read_function },
3858   {"cleanup", 1, cleanup_pairs },
3859   {"generate_large_pairs", 1, generate_large_pairs },
3860   {"generate_data", 1, generate_data },
3861   {"generate_buffer_data", 1, generate_buffer_data },
3862   {"cleanup", 1, cleanup_pairs },
3863   {0, 0, 0}
3864 };
3865
3866 test_st consistent_tests[] ={
3867   {"generate_pairs", 1, generate_pairs },
3868   {"generate_data", 1, generate_data },
3869   {"get_read", 0, get_read_count },
3870   {"cleanup", 1, cleanup_pairs },
3871   {0, 0, 0}
3872 };
3873
3874 test_st consistent_weighted_tests[] ={
3875   {"generate_pairs", 1, generate_pairs },
3876   {"generate_data", 1, generate_data_with_stats },
3877   {"get_read", 0, get_read_count },
3878   {"cleanup", 1, cleanup_pairs },
3879   {0, 0, 0}
3880 };
3881
3882 test_st hsieh_availability[] ={
3883   {"hsieh_avaibility_test",0,hsieh_avaibility_test},
3884   {0, 0, 0}
3885 };
3886
3887 test_st ketama_auto_eject_hosts[] ={
3888   {"auto_eject_hosts", 1, auto_eject_hosts },
3889   {0, 0, 0}
3890 };
3891
3892 collection_st collection[] ={
3893   {"hsieh_availability",0,0,hsieh_availability},
3894   {"udp_setup", init_udp, 0, udp_setup_server_tests},
3895   {"udp_io", init_udp, 0, upd_io_tests},
3896   {"udp_binary_io", binary_init_udp, 0, upd_io_tests},
3897   {"block", 0, 0, tests},
3898   {"binary", pre_binary, 0, tests},
3899   {"nonblock", pre_nonblock, 0, tests},
3900   {"nodelay", pre_nodelay, 0, tests},
3901   {"settimer", pre_settimer, 0, tests},
3902   {"md5", pre_md5, 0, tests},
3903   {"crc", pre_crc, 0, tests},
3904   {"hsieh", pre_hsieh, 0, tests},
3905   {"jenkins", pre_jenkins, 0, tests},
3906   {"fnv1_64", pre_hash_fnv1_64, 0, tests},
3907   {"fnv1a_64", pre_hash_fnv1a_64, 0, tests},
3908   {"fnv1_32", pre_hash_fnv1_32, 0, tests},
3909   {"fnv1a_32", pre_hash_fnv1a_32, 0, tests},
3910   {"ketama", pre_behavior_ketama, 0, tests},
3911   {"ketama_auto_eject_hosts", pre_behavior_ketama, 0, ketama_auto_eject_hosts},
3912   {"unix_socket", pre_unix_socket, 0, tests},
3913   {"unix_socket_nodelay", pre_nodelay, 0, tests},
3914   {"poll_timeout", poll_timeout, 0, tests},
3915   {"gets", enable_cas, 0, tests},
3916   {"consistent", enable_consistent, 0, tests},
3917   {"memory_allocators", set_memory_alloc, 0, tests},
3918   {"prefix", set_prefix, 0, tests},
3919   {"version_1_2_3", check_for_1_2_3, 0, version_1_2_3},
3920   {"string", 0, 0, string_tests},
3921   {"result", 0, 0, result_tests},
3922   {"async", pre_nonblock, 0, async_tests},
3923   {"async_binary", pre_nonblock_binary, 0, async_tests},
3924   {"user", 0, 0, user_tests},
3925   {"generate", 0, 0, generate_tests},
3926   {"generate_hsieh", pre_hsieh, 0, generate_tests},
3927   {"generate_ketama", pre_behavior_ketama, 0, generate_tests},
3928   {"generate_hsieh_consistent", enable_consistent, 0, generate_tests},
3929   {"generate_md5", pre_md5, 0, generate_tests},
3930   {"generate_murmur", pre_murmur, 0, generate_tests},
3931   {"generate_jenkins", pre_jenkins, 0, generate_tests},
3932   {"generate_nonblock", pre_nonblock, 0, generate_tests},
3933   {"consistent_not", 0, 0, consistent_tests},
3934   {"consistent_ketama", pre_behavior_ketama, 0, consistent_tests},
3935   {"consistent_ketama_weighted", pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
3936   {0, 0, 0, 0}
3937 };
3938
3939 #define SERVERS_TO_CREATE 5
3940
3941 /* Prototypes for functions we will pass to test framework */
3942 void *world_create(void);
3943 void world_destroy(void *p);
3944
3945 void *world_create(void)
3946 {
3947   server_startup_st *construct;
3948
3949   construct= (server_startup_st *)malloc(sizeof(server_startup_st));
3950   memset(construct, 0, sizeof(server_startup_st));
3951   construct->count= SERVERS_TO_CREATE;
3952   construct->udp= 0;
3953   server_startup(construct);
3954
3955   return construct;
3956 }
3957
3958
3959 void world_destroy(void *p)
3960 {
3961   server_startup_st *construct= (server_startup_st *)p;
3962   memcached_server_st *servers= (memcached_server_st *)construct->servers;
3963   memcached_server_list_free(servers);
3964
3965   server_shutdown(construct);
3966   free(construct);
3967 }
3968
3969 void get_world(world_st *world)
3970 {
3971   world->collections= collection;
3972   world->create= world_create;
3973   world->destroy= world_destroy;
3974 }