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

   1 /* libMemcached Functions Test
   2  * Copyright (C) 2006-2009 Brian Aker
   3  * All rights reserved.
   4  *
   5  * Use and distribution licensed under the BSD license.  See
   6  * the COPYING file in the parent directory for full text.
   7  */
   8
   9 /*
  10   Sample test application.
  11 */
  12
  13 #include "config.h"
  14
  15 #include <assert.h>
  16 #include <stdio.h>
  17 #include <stdint.h>
  18 #include <stdlib.h>
  19 #include <string.h>
  20 #include <sys/time.h>
  21 #include <sys/types.h>
  22 #include <sys/stat.h>
  23 #include <signal.h>
  24 #include <unistd.h>
  25 #include <time.h>
  26
  27 #include "libmemcached/common.h"
  28
  29 #include "server.h"
  30 #include "clients/generator.h"
  31 #include "clients/execute.h"
  32
  33 #define SMALL_STRING_LEN 1024
  34
  35 #include "test.h"
  36
  37
  38 #ifdef HAVE_LIBMEMCACHEDUTIL
  39 #include <pthread.h>
  40 #include "libmemcached/memcached_util.h"
  41 #endif
  42
  43 #include "hash_results.h"
  44
  45 #define GLOBAL_COUNT 10000
  46 #define GLOBAL2_COUNT 100
  47 #define SERVERS_TO_CREATE 5
  48 static uint32_t global_count;
  49
  50 static pairs_st *global_pairs;
  51 static const char *global_keys[GLOBAL_COUNT];
  52 static size_t global_keys_length[GLOBAL_COUNT];
  53
  54 // Prototype
  55 static test_return_t pre_binary(memcached_st *memc);
  56
  57
  58 static test_return_t init_test(memcached_st *not_used __attribute__((unused)))
  59 {
  60   memcached_st memc;
  61
  62   (void)memcached_create(&memc);
  63   memcached_free(&memc);
  64
  65   return TEST_SUCCESS;
  66 }
  67
  68 static test_return_t server_list_null_test(memcached_st *ptr __attribute__((unused)))
  69 {
  70   memcached_server_st *server_list;
  71   memcached_return_t rc;
  72
  73   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, NULL);
  74   test_true(server_list == NULL);
  75
  76   server_list= memcached_server_list_append_with_weight(NULL, "localhost", 0, 0, NULL);
  77   test_true(server_list == NULL);
  78
  79   server_list= memcached_server_list_append_with_weight(NULL, NULL, 0, 0, &rc);
  80   test_true(server_list == NULL);
  81
  82   return TEST_SUCCESS;
  83 }
  84
  85 #define TEST_PORT_COUNT 7
  86 in_port_t test_ports[TEST_PORT_COUNT];
  87
  88 static memcached_return_t  server_display_function(const memcached_st *ptr __attribute__((unused)),
  89                                                    const memcached_server_st *server,
  90                                                    void *context)
  91 {
  92   /* Do Nothing */
  93   size_t bigger= *((size_t *)(context));
  94   assert(bigger <= memcached_server_port(server));
  95   *((size_t *)(context))= memcached_server_port(server);
  96
  97   return MEMCACHED_SUCCESS;
  98 }
  99
 100 static memcached_return_t dump_server_information(const memcached_st *ptr __attribute__((unused)),
 101                                                   const memcached_server_st *instance,
 102                                                   void *context)
 103 {
 104   /* Do Nothing */
 105   FILE *stream= (FILE *)context;
 106
 107   fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
 108           memcached_server_name(instance),
 109           memcached_server_port(instance),
 110           instance->major_version,
 111           instance->minor_version,
 112           instance->micro_version);
 113
 114   return MEMCACHED_SUCCESS;
 115 }
 116
 117 static test_return_t server_sort_test(memcached_st *ptr __attribute__((unused)))
 118 {
 119   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
 120
 121   memcached_return_t rc;
 122   memcached_server_fn callbacks[1];
 123   memcached_st *local_memc;
 124
 125   local_memc= memcached_create(NULL);
 126   test_true(local_memc);
 127   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 128
 129   for (size_t x= 0; x < TEST_PORT_COUNT; x++)
 130   {
 131     test_ports[x]= (in_port_t)random() % 64000;
 132     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
 133     test_true(memcached_server_count(local_memc) == x + 1);
 134 #if 0 // Rewrite
 135     test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
 136 #endif
 137     test_true(rc == MEMCACHED_SUCCESS);
 138   }
 139
 140   callbacks[0]= server_display_function;
 141   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 142
 143
 144   memcached_free(local_memc);
 145
 146   return TEST_SUCCESS;
 147 }
 148
 149 static test_return_t server_sort2_test(memcached_st *ptr __attribute__((unused)))
 150 {
 151   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
 152   memcached_return_t rc;
 153   memcached_server_fn callbacks[1];
 154   memcached_st *local_memc;
 155   memcached_server_instance_st instance;
 156
 157   local_memc= memcached_create(NULL);
 158   test_true(local_memc);
 159   rc= memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 160   test_true(rc == MEMCACHED_SUCCESS);
 161
 162   rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0);
 163   test_true(rc == MEMCACHED_SUCCESS);
 164   instance= memcached_server_instance_by_position(local_memc, 0);
 165   test_true(memcached_server_port(instance) == 43043);
 166
 167   rc= memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0);
 168   test_true(rc == MEMCACHED_SUCCESS);
 169
 170   instance= memcached_server_instance_by_position(local_memc, 0);
 171   test_true(memcached_server_port(instance) == 43042);
 172
 173   instance= memcached_server_instance_by_position(local_memc, 1);
 174   test_true(memcached_server_port(instance) == 43043);
 175
 176   callbacks[0]= server_display_function;
 177   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 178
 179
 180   memcached_free(local_memc);
 181
 182   return TEST_SUCCESS;
 183 }
 184
 185 static memcached_return_t server_print_callback(const memcached_st *ptr __attribute__((unused)),
 186                                                 const memcached_server_st *server,
 187                                                 void *context __attribute__((unused)))
 188 {
 189   (void)server; // Just in case we aren't printing.
 190
 191 #if 0
 192   fprintf(stderr, "%s(%d)", memcached_server_name(server), memcached_server_port(server));
 193 #endif
 194
 195   return MEMCACHED_SUCCESS;
 196 }
 197
 198 static test_return_t memcached_server_remove_test(memcached_st *ptr __attribute__((unused)))
 199 {
 200   memcached_return_t rc;
 201   memcached_st local_memc;
 202   memcached_st *memc;
 203   memcached_server_st *servers;
 204   memcached_server_fn callbacks[1];
 205
 206   const char *server_string= "localhost:4444, localhost:4445, localhost:4446, localhost:4447, localhost, 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";
 207
 208   memc= memcached_create(&local_memc);
 209
 210   servers= memcached_servers_parse(server_string);
 211
 212   rc= memcached_server_push(memc, servers);
 213   memcached_server_list_free(servers);
 214
 215   callbacks[0]= server_print_callback;
 216   memcached_server_cursor(memc, callbacks, NULL,  1);
 217
 218   memcached_free(memc);
 219
 220   return TEST_SUCCESS;
 221 }
 222
 223 static memcached_return_t server_display_unsort_function(const memcached_st *ptr __attribute__((unused)),
 224                                                          const memcached_server_st *server,
 225                                                          void *context)
 226 {
 227   /* Do Nothing */
 228   uint32_t x= *((uint32_t *)(context));
 229
 230   assert(test_ports[x] == server->port);
 231   *((uint32_t *)(context))= ++x;
 232
 233   return MEMCACHED_SUCCESS;
 234 }
 235
 236 static test_return_t server_unsort_test(memcached_st *ptr __attribute__((unused)))
 237 {
 238   size_t counter= 0; /* Prime the value for the test_true in server_display_function */
 239   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
 240   memcached_return_t rc;
 241   memcached_server_fn callbacks[1];
 242   memcached_st *local_memc;
 243
 244   local_memc= memcached_create(NULL);
 245   test_true(local_memc);
 246
 247   for (size_t x= 0; x < TEST_PORT_COUNT; x++)
 248   {
 249     test_ports[x]= (in_port_t)(random() % 64000);
 250     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
 251     test_true(memcached_server_count(local_memc) == x+1);
 252 #if 0 // Rewrite
 253     test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
 254 #endif
 255     test_true(rc == MEMCACHED_SUCCESS);
 256   }
 257
 258   callbacks[0]= server_display_unsort_function;
 259   memcached_server_cursor(local_memc, callbacks, (void *)&counter,  1);
 260
 261   /* Now we sort old data! */
 262   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 263   callbacks[0]= server_display_function;
 264   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 265
 266
 267   memcached_free(local_memc);
 268
 269   return TEST_SUCCESS;
 270 }
 271
 272 static test_return_t allocation_test(memcached_st *not_used __attribute__((unused)))
 273 {
 274   memcached_st *memc;
 275   memc= memcached_create(NULL);
 276   test_true(memc);
 277   memcached_free(memc);
 278
 279   return TEST_SUCCESS;
 280 }
 281
 282 static test_return_t clone_test(memcached_st *memc)
 283 {
 284   /* All null? */
 285   {
 286     memcached_st *memc_clone;
 287     memc_clone= memcached_clone(NULL, NULL);
 288     test_true(memc_clone);
 289     memcached_free(memc_clone);
 290   }
 291
 292   /* Can we init from null? */
 293   {
 294     memcached_st *memc_clone;
 295     memc_clone= memcached_clone(NULL, memc);
 296     test_true(memc_clone);
 297
 298     { // Test allocators
 299       test_true(memc_clone->allocators.free == memc->allocators.free);
 300       test_true(memc_clone->allocators.malloc == memc->allocators.malloc);
 301       test_true(memc_clone->allocators.realloc == memc->allocators.realloc);
 302       test_true(memc_clone->allocators.calloc == memc->allocators.calloc);
 303     }
 304
 305     test_true(memc_clone->connect_timeout == memc->connect_timeout);
 306     test_true(memc_clone->delete_trigger == memc->delete_trigger);
 307     test_true(memc_clone->distribution == memc->distribution);
 308     { // Test all of the flags
 309       test_true(memc_clone->flags.no_block == memc->flags.no_block);
 310       test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
 311       test_true(memc_clone->flags.reuse_memory == memc->flags.reuse_memory);
 312       test_true(memc_clone->flags.use_cache_lookups == memc->flags.use_cache_lookups);
 313       test_true(memc_clone->flags.support_cas == memc->flags.support_cas);
 314       test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
 315       test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
 316       test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
 317       test_true(memc_clone->flags.ketama_weighted == memc->flags.ketama_weighted);
 318       test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
 319       test_true(memc_clone->flags.hash_with_prefix_key == memc->flags.hash_with_prefix_key);
 320       test_true(memc_clone->flags.no_reply == memc->flags.no_reply);
 321       test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
 322       test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
 323       test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);
 324     }
 325     test_true(memc_clone->get_key_failure == memc->get_key_failure);
 326     test_true(hashkit_compare(&memc_clone->hashkit, &memc->hashkit));
 327     test_true(hashkit_compare(&memc_clone->distribution_hashkit, &memc->distribution_hashkit));
 328     test_true(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
 329     test_true(memc_clone->io_msg_watermark == memc->io_msg_watermark);
 330     test_true(memc_clone->io_key_prefetch == memc->io_key_prefetch);
 331     test_true(memc_clone->on_cleanup == memc->on_cleanup);
 332     test_true(memc_clone->on_clone == memc->on_clone);
 333     test_true(memc_clone->poll_timeout == memc->poll_timeout);
 334     test_true(memc_clone->rcv_timeout == memc->rcv_timeout);
 335     test_true(memc_clone->recv_size == memc->recv_size);
 336     test_true(memc_clone->retry_timeout == memc->retry_timeout);
 337     test_true(memc_clone->send_size == memc->send_size);
 338     test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
 339     test_true(memc_clone->snd_timeout == memc->snd_timeout);
 340     test_true(memc_clone->user_data == memc->user_data);
 341
 342     memcached_free(memc_clone);
 343   }
 344
 345   /* Can we init from struct? */
 346   {
 347     memcached_st declared_clone;
 348     memcached_st *memc_clone;
 349     memset(&declared_clone, 0 , sizeof(memcached_st));
 350     memc_clone= memcached_clone(&declared_clone, NULL);
 351     test_true(memc_clone);
 352     memcached_free(memc_clone);
 353   }
 354
 355   /* Can we init from struct? */
 356   {
 357     memcached_st declared_clone;
 358     memcached_st *memc_clone;
 359     memset(&declared_clone, 0 , sizeof(memcached_st));
 360     memc_clone= memcached_clone(&declared_clone, memc);
 361     test_true(memc_clone);
 362     memcached_free(memc_clone);
 363   }
 364
 365   return TEST_SUCCESS;
 366 }
 367
 368 static test_return_t userdata_test(memcached_st *memc)
 369 {
 370   void* foo= NULL;
 371   test_true(memcached_set_user_data(memc, foo) == NULL);
 372   test_true(memcached_get_user_data(memc) == foo);
 373   test_true(memcached_set_user_data(memc, NULL) == foo);
 374
 375   return TEST_SUCCESS;
 376 }
 377
 378 static test_return_t connection_test(memcached_st *memc)
 379 {
 380   memcached_return_t rc;
 381
 382   rc= memcached_server_add_with_weight(memc, "localhost", 0, 0);
 383   test_true(rc == MEMCACHED_SUCCESS);
 384
 385   return TEST_SUCCESS;
 386 }
 387
 388 static test_return_t error_test(memcached_st *memc)
 389 {
 390   memcached_return_t rc;
 391   uint32_t values[] = { 851992627U, 2337886783U, 3196981036U, 4001849190U,
 392                         982370485U, 1263635348U, 4242906218U, 3829656100U,
 393                         1891735253U, 334139633U, 2257084983U, 3088286104U,
 394                         13199785U, 2542027183U, 1097051614U, 199566778U,
 395                         2748246961U, 2465192557U, 1664094137U, 2405439045U,
 396                         1842224848U, 692413798U, 3479807801U, 919913813U,
 397                         4269430871U, 610793021U, 527273862U, 1437122909U,
 398                         2300930706U, 2943759320U, 674306647U, 2400528935U,
 399                         54481931U, 4186304426U, 1741088401U, 2979625118U,
 400                         4159057246U, 3425930182U, 2593724503U,  1868899624U,
 401                         1769812374U, 2302537950U, 1110330676U };
 402
 403   // You have updated the memcache_error messages but not updated docs/tests.
 404   test_true(MEMCACHED_MAXIMUM_RETURN == 43);
 405   for (rc= MEMCACHED_SUCCESS; rc < MEMCACHED_MAXIMUM_RETURN; rc++)
 406   {
 407     uint32_t hash_val;
 408     const char *msg=  memcached_strerror(memc, rc);
 409     hash_val= memcached_generate_hash_value(msg, strlen(msg),
 410                                             MEMCACHED_HASH_JENKINS);
 411     if (values[rc] != hash_val)
 412     {
 413       fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the error_test\n");
 414       fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, rc), hash_val);
 415     }
 416     test_true(values[rc] == hash_val);
 417   }
 418
 419   return TEST_SUCCESS;
 420 }
 421
 422 static test_return_t set_test(memcached_st *memc)
 423 {
 424   memcached_return_t rc;
 425   const char *key= "foo";
 426   const char *value= "when we sanitize";
 427
 428   rc= memcached_set(memc, key, strlen(key),
 429                     value, strlen(value),
 430                     (time_t)0, (uint32_t)0);
 431   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 432
 433   return TEST_SUCCESS;
 434 }
 435
 436 static test_return_t append_test(memcached_st *memc)
 437 {
 438   memcached_return_t rc;
 439   const char *key= "fig";
 440   const char *in_value= "we";
 441   char *out_value= NULL;
 442   size_t value_length;
 443   uint32_t flags;
 444
 445   rc= memcached_flush(memc, 0);
 446   test_true(rc == MEMCACHED_SUCCESS);
 447
 448   rc= memcached_set(memc, key, strlen(key),
 449                     in_value, strlen(in_value),
 450                     (time_t)0, (uint32_t)0);
 451   test_true(rc == MEMCACHED_SUCCESS);
 452
 453   rc= memcached_append(memc, key, strlen(key),
 454                        " the", strlen(" the"),
 455                        (time_t)0, (uint32_t)0);
 456   test_true(rc == MEMCACHED_SUCCESS);
 457
 458   rc= memcached_append(memc, key, strlen(key),
 459                        " people", strlen(" people"),
 460                        (time_t)0, (uint32_t)0);
 461   test_true(rc == MEMCACHED_SUCCESS);
 462
 463   out_value= memcached_get(memc, key, strlen(key),
 464                        &value_length, &flags, &rc);
 465   test_true(!memcmp(out_value, "we the people", strlen("we the people")));
 466   test_true(strlen("we the people") == value_length);
 467   test_true(rc == MEMCACHED_SUCCESS);
 468   free(out_value);
 469
 470   return TEST_SUCCESS;
 471 }
 472
 473 static test_return_t append_binary_test(memcached_st *memc)
 474 {
 475   memcached_return_t rc;
 476   const char *key= "numbers";
 477   uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };
 478   uint32_t *value;
 479   size_t value_length;
 480   uint32_t flags;
 481   uint32_t x;
 482
 483   rc= memcached_flush(memc, 0);
 484   test_true(rc == MEMCACHED_SUCCESS);
 485
 486   rc= memcached_set(memc,
 487                     key, strlen(key),
 488                     NULL, 0,
 489                     (time_t)0, (uint32_t)0);
 490   test_true(rc == MEMCACHED_SUCCESS);
 491
 492   for (x= 0; store_list[x] ; x++)
 493   {
 494     rc= memcached_append(memc,
 495                          key, strlen(key),
 496                          (char *)&store_list[x], sizeof(uint32_t),
 497                          (time_t)0, (uint32_t)0);
 498     test_true(rc == MEMCACHED_SUCCESS);
 499   }
 500
 501   value= (uint32_t *)memcached_get(memc, key, strlen(key),
 502                        &value_length, &flags, &rc);
 503   test_true((value_length == (sizeof(uint32_t) * x)));
 504   test_true(rc == MEMCACHED_SUCCESS);
 505
 506   for (uint32_t counter= x, *ptr= value; counter; counter--)
 507   {
 508     test_true(*ptr == store_list[x - counter]);
 509     ptr++;
 510   }
 511   free(value);
 512
 513   return TEST_SUCCESS;
 514 }
 515
 516 static test_return_t cas2_test(memcached_st *memc)
 517 {
 518   memcached_return_t rc;
 519   const char *keys[]= {"fudge", "son", "food"};
 520   size_t key_length[]= {5, 3, 4};
 521   const char *value= "we the people";
 522   size_t value_length= strlen("we the people");
 523   unsigned int x;
 524   memcached_result_st results_obj;
 525   memcached_result_st *results;
 526   unsigned int set= 1;
 527
 528   rc= memcached_flush(memc, 0);
 529   test_true(rc == MEMCACHED_SUCCESS);
 530
 531   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 532
 533   for (x= 0; x < 3; x++)
 534   {
 535     rc= memcached_set(memc, keys[x], key_length[x],
 536                       keys[x], key_length[x],
 537                       (time_t)50, (uint32_t)9);
 538     test_true(rc == MEMCACHED_SUCCESS);
 539   }
 540
 541   rc= memcached_mget(memc, keys, key_length, 3);
 542
 543   results= memcached_result_create(memc, &results_obj);
 544
 545   results= memcached_fetch_result(memc, &results_obj, &rc);
 546   test_true(results);
 547   test_true(results->item_cas);
 548   test_true(rc == MEMCACHED_SUCCESS);
 549   test_true(memcached_result_cas(results));
 550
 551   test_true(!memcmp(value, "we the people", strlen("we the people")));
 552   test_true(strlen("we the people") == value_length);
 553   test_true(rc == MEMCACHED_SUCCESS);
 554
 555   memcached_result_free(&results_obj);
 556
 557   return TEST_SUCCESS;
 558 }
 559
 560 static test_return_t cas_test(memcached_st *memc)
 561 {
 562   memcached_return_t rc;
 563   const char *key= "fun";
 564   size_t key_length= strlen(key);
 565   const char *value= "we the people";
 566   const char* keys[2] = { key, NULL };
 567   size_t keylengths[2] = { strlen(key), 0 };
 568   size_t value_length= strlen(value);
 569   const char *value2= "change the value";
 570   size_t value2_length= strlen(value2);
 571
 572   memcached_result_st results_obj;
 573   memcached_result_st *results;
 574   unsigned int set= 1;
 575
 576   rc= memcached_flush(memc, 0);
 577   test_true(rc == MEMCACHED_SUCCESS);
 578
 579   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
 580
 581   rc= memcached_set(memc, key, strlen(key),
 582                     value, strlen(value),
 583                     (time_t)0, (uint32_t)0);
 584   test_true(rc == MEMCACHED_SUCCESS);
 585
 586   rc= memcached_mget(memc, keys, keylengths, 1);
 587
 588   results= memcached_result_create(memc, &results_obj);
 589
 590   results= memcached_fetch_result(memc, &results_obj, &rc);
 591   test_true(results);
 592   test_true(rc == MEMCACHED_SUCCESS);
 593   test_true(memcached_result_cas(results));
 594   test_true(!memcmp(value, memcached_result_value(results), value_length));
 595   test_true(strlen(memcached_result_value(results)) == value_length);
 596   test_true(rc == MEMCACHED_SUCCESS);
 597   uint64_t cas = memcached_result_cas(results);
 598
 599 #if 0
 600   results= memcached_fetch_result(memc, &results_obj, &rc);
 601   test_true(rc == MEMCACHED_END);
 602   test_true(results == NULL);
 603 #endif
 604
 605   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
 606   test_true(rc == MEMCACHED_SUCCESS);
 607
 608   /*
 609    * The item will have a new cas value, so try to set it again with the old
 610    * value. This should fail!
 611    */
 612   rc= memcached_cas(memc, key, key_length, value2, value2_length, 0, 0, cas);
 613   test_true(rc == MEMCACHED_DATA_EXISTS);
 614
 615   memcached_result_free(&results_obj);
 616
 617   return TEST_SUCCESS;
 618 }
 619
 620 static test_return_t prepend_test(memcached_st *memc)
 621 {
 622   memcached_return_t rc;
 623   const char *key= "fig";
 624   const char *value= "people";
 625   char *out_value= NULL;
 626   size_t value_length;
 627   uint32_t flags;
 628
 629   rc= memcached_flush(memc, 0);
 630   test_true(rc == MEMCACHED_SUCCESS);
 631
 632   rc= memcached_set(memc, key, strlen(key),
 633                     value, strlen(value),
 634                     (time_t)0, (uint32_t)0);
 635   test_true(rc == MEMCACHED_SUCCESS);
 636
 637   rc= memcached_prepend(memc, key, strlen(key),
 638                        "the ", strlen("the "),
 639                        (time_t)0, (uint32_t)0);
 640   test_true(rc == MEMCACHED_SUCCESS);
 641
 642   rc= memcached_prepend(memc, key, strlen(key),
 643                        "we ", strlen("we "),
 644                        (time_t)0, (uint32_t)0);
 645   test_true(rc == MEMCACHED_SUCCESS);
 646
 647   out_value= memcached_get(memc, key, strlen(key),
 648                        &value_length, &flags, &rc);
 649   test_true(!memcmp(out_value, "we the people", strlen("we the people")));
 650   test_true(strlen("we the people") == value_length);
 651   test_true(rc == MEMCACHED_SUCCESS);
 652   free(out_value);
 653
 654   return TEST_SUCCESS;
 655 }
 656
 657 /*
 658   Set the value, then quit to make sure it is flushed.
 659   Come back in and test that add fails.
 660 */
 661 static test_return_t add_test(memcached_st *memc)
 662 {
 663   memcached_return_t rc;
 664   const char *key= "foo";
 665   const char *value= "when we sanitize";
 666   unsigned long long setting_value;
 667
 668   setting_value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
 669
 670   rc= memcached_set(memc, key, strlen(key),
 671                     value, strlen(value),
 672                     (time_t)0, (uint32_t)0);
 673   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 674   memcached_quit(memc);
 675   rc= memcached_add(memc, key, strlen(key),
 676                     value, strlen(value),
 677                     (time_t)0, (uint32_t)0);
 678
 679   /* Too many broken OS'es have broken loopback in async, so we can't be sure of the result */
 680   if (setting_value)
 681   {
 682     test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_STORED);
 683   }
 684   else
 685   {
 686     test_true(rc == MEMCACHED_NOTSTORED || rc == MEMCACHED_DATA_EXISTS);
 687   }
 688
 689   return TEST_SUCCESS;
 690 }
 691
 692 /*
 693 ** There was a problem of leaking filedescriptors in the initial release
 694 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
 695 ** systems it seems that the kernel is slow on reclaiming the resources
 696 ** because the connects starts to time out (the test doesn't do much
 697 ** anyway, so just loop 10 iterations)
 698 */
 699 static test_return_t add_wrapper(memcached_st *memc)
 700 {
 701   unsigned int max= 10000;
 702 #ifdef __sun
 703   max= 10;
 704 #endif
 705 #ifdef __APPLE__
 706   max= 10;
 707 #endif
 708
 709   for (uint32_t x= 0; x < max; x++)
 710     add_test(memc);
 711
 712   return TEST_SUCCESS;
 713 }
 714
 715 static test_return_t replace_test(memcached_st *memc)
 716 {
 717   memcached_return_t rc;
 718   const char *key= "foo";
 719   const char *value= "when we sanitize";
 720   const char *original= "first we insert some data";
 721
 722   rc= memcached_set(memc, key, strlen(key),
 723                     original, strlen(original),
 724                     (time_t)0, (uint32_t)0);
 725   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 726
 727   rc= memcached_replace(memc, key, strlen(key),
 728                     value, strlen(value),
 729                     (time_t)0, (uint32_t)0);
 730   test_true(rc == MEMCACHED_SUCCESS);
 731
 732   return TEST_SUCCESS;
 733 }
 734
 735 static test_return_t delete_test(memcached_st *memc)
 736 {
 737   memcached_return_t rc;
 738   const char *key= "foo";
 739   const char *value= "when we sanitize";
 740
 741   rc= memcached_set(memc, key, strlen(key),
 742                     value, strlen(value),
 743                     (time_t)0, (uint32_t)0);
 744   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 745
 746   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 747   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 748
 749   return TEST_SUCCESS;
 750 }
 751
 752 static test_return_t flush_test(memcached_st *memc)
 753 {
 754   memcached_return_t rc;
 755
 756   rc= memcached_flush(memc, 0);
 757   test_true(rc == MEMCACHED_SUCCESS);
 758
 759   return TEST_SUCCESS;
 760 }
 761
 762 static memcached_return_t  server_function(const memcached_st *ptr __attribute__((unused)),
 763                                            const memcached_server_st *server __attribute__((unused)),
 764                                            void *context __attribute__((unused)))
 765 {
 766   /* Do Nothing */
 767
 768   return MEMCACHED_SUCCESS;
 769 }
 770
 771 static test_return_t memcached_server_cursor_test(memcached_st *memc)
 772 {
 773   char context[8];
 774   strcpy(context, "foo bad");
 775   memcached_server_fn callbacks[1];
 776
 777   callbacks[0]= server_function;
 778   memcached_server_cursor(memc, callbacks, context,  1);
 779   return TEST_SUCCESS;
 780 }
 781
 782 static test_return_t bad_key_test(memcached_st *memc)
 783 {
 784   memcached_return_t rc;
 785   const char *key= "foo bad";
 786   char *string;
 787   size_t string_length;
 788   uint32_t flags;
 789   memcached_st *memc_clone;
 790   unsigned int set= 1;
 791   size_t max_keylen= 0xffff;
 792
 793   // Just skip if we are in binary mode.
 794   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
 795     return TEST_SKIPPED;
 796
 797   memc_clone= memcached_clone(NULL, memc);
 798   test_true(memc_clone);
 799
 800   rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 801   test_true(rc == MEMCACHED_SUCCESS);
 802
 803   /* All keys are valid in the binary protocol (except for length) */
 804   if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 0)
 805   {
 806     string= memcached_get(memc_clone, key, strlen(key),
 807                           &string_length, &flags, &rc);
 808     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
 809     test_true(string_length ==  0);
 810     test_true(!string);
 811
 812     set= 0;
 813     rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 814     test_true(rc == MEMCACHED_SUCCESS);
 815     string= memcached_get(memc_clone, key, strlen(key),
 816                           &string_length, &flags, &rc);
 817     test_true(rc == MEMCACHED_NOTFOUND);
 818     test_true(string_length ==  0);
 819     test_true(!string);
 820
 821     /* Test multi key for bad keys */
 822     const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
 823     size_t key_lengths[] = { 7, 7, 7 };
 824     set= 1;
 825     rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 826     test_true(rc == MEMCACHED_SUCCESS);
 827
 828     rc= memcached_mget(memc_clone, keys, key_lengths, 3);
 829     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
 830
 831     rc= memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1);
 832     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
 833
 834     max_keylen= 250;
 835
 836     /* The following test should be moved to the end of this function when the
 837        memcached server is updated to allow max size length of the keys in the
 838        binary protocol
 839     */
 840     rc= memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
 841     test_true(rc == MEMCACHED_SUCCESS);
 842
 843     char *longkey= malloc(max_keylen + 1);
 844     if (longkey != NULL)
 845     {
 846       memset(longkey, 'a', max_keylen + 1);
 847       string= memcached_get(memc_clone, longkey, max_keylen,
 848                             &string_length, &flags, &rc);
 849       test_true(rc == MEMCACHED_NOTFOUND);
 850       test_true(string_length ==  0);
 851       test_true(!string);
 852
 853       string= memcached_get(memc_clone, longkey, max_keylen + 1,
 854                             &string_length, &flags, &rc);
 855       test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
 856       test_true(string_length ==  0);
 857       test_true(!string);
 858
 859       free(longkey);
 860     }
 861   }
 862
 863   /* Make sure zero length keys are marked as bad */
 864   set= 1;
 865   rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, set);
 866   test_true(rc == MEMCACHED_SUCCESS);
 867   string= memcached_get(memc_clone, key, 0,
 868                         &string_length, &flags, &rc);
 869   test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
 870   test_true(string_length ==  0);
 871   test_true(!string);
 872
 873   memcached_free(memc_clone);
 874
 875   return TEST_SUCCESS;
 876 }
 877
 878 #define READ_THROUGH_VALUE "set for me"
 879 static memcached_return_t read_through_trigger(memcached_st *memc __attribute__((unused)),
 880                                                char *key __attribute__((unused)),
 881                                                size_t key_length __attribute__((unused)),
 882                                                memcached_result_st *result)
 883 {
 884
 885   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
 886 }
 887
 888 static test_return_t read_through(memcached_st *memc)
 889 {
 890   memcached_return_t rc;
 891   const char *key= "foo";
 892   char *string;
 893   size_t string_length;
 894   uint32_t flags;
 895   memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
 896
 897   string= memcached_get(memc, key, strlen(key),
 898                         &string_length, &flags, &rc);
 899
 900   test_true(rc == MEMCACHED_NOTFOUND);
 901   test_false(string_length);
 902   test_false(string);
 903
 904   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE,
 905                              *(void **)&cb);
 906   test_true(rc == MEMCACHED_SUCCESS);
 907
 908   string= memcached_get(memc, key, strlen(key),
 909                         &string_length, &flags, &rc);
 910
 911   test_true(rc == MEMCACHED_SUCCESS);
 912   test_true(string_length ==  strlen(READ_THROUGH_VALUE));
 913   test_strcmp(READ_THROUGH_VALUE, string);
 914   free(string);
 915
 916   string= memcached_get(memc, key, strlen(key),
 917                         &string_length, &flags, &rc);
 918
 919   test_true(rc == MEMCACHED_SUCCESS);
 920   test_true(string_length ==  strlen(READ_THROUGH_VALUE));
 921   test_true(!strcmp(READ_THROUGH_VALUE, string));
 922   free(string);
 923
 924   return TEST_SUCCESS;
 925 }
 926
 927 static memcached_return_t  delete_trigger(memcached_st *ptr __attribute__((unused)),
 928                                           const char *key,
 929                                           size_t key_length __attribute__((unused)))
 930 {
 931   assert(key);
 932
 933   return MEMCACHED_SUCCESS;
 934 }
 935
 936 static test_return_t delete_through(memcached_st *memc)
 937 {
 938   memcached_trigger_delete_key_fn callback;
 939   memcached_return_t rc;
 940
 941   callback= (memcached_trigger_delete_key_fn)delete_trigger;
 942
 943   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_DELETE_TRIGGER, *(void**)&callback);
 944   test_true(rc == MEMCACHED_SUCCESS);
 945
 946   return TEST_SUCCESS;
 947 }
 948
 949 static test_return_t get_test(memcached_st *memc)
 950 {
 951   memcached_return_t rc;
 952   const char *key= "foo";
 953   char *string;
 954   size_t string_length;
 955   uint32_t flags;
 956
 957   rc= memcached_delete(memc, key, strlen(key), (time_t)0);
 958   test_true(rc == MEMCACHED_BUFFERED || rc == MEMCACHED_NOTFOUND);
 959
 960   string= memcached_get(memc, key, strlen(key),
 961                         &string_length, &flags, &rc);
 962
 963   test_true(rc == MEMCACHED_NOTFOUND);
 964   test_false(string_length);
 965   test_false(string);
 966
 967   return TEST_SUCCESS;
 968 }
 969
 970 static test_return_t get_test2(memcached_st *memc)
 971 {
 972   memcached_return_t rc;
 973   const char *key= "foo";
 974   const char *value= "when we sanitize";
 975   char *string;
 976   size_t string_length;
 977   uint32_t flags;
 978
 979   rc= memcached_set(memc, key, strlen(key),
 980                     value, strlen(value),
 981                     (time_t)0, (uint32_t)0);
 982   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
 983
 984   string= memcached_get(memc, key, strlen(key),
 985                         &string_length, &flags, &rc);
 986
 987   test_true(string);
 988   test_true(rc == MEMCACHED_SUCCESS);
 989   test_true(string_length == strlen(value));
 990   test_true(!memcmp(string, value, string_length));
 991
 992   free(string);
 993
 994   return TEST_SUCCESS;
 995 }
 996
 997 static test_return_t set_test2(memcached_st *memc)
 998 {
 999   memcached_return_t rc;
1000   const char *key= "foo";
1001   const char *value= "train in the brain";
1002   size_t value_length= strlen(value);
1003   unsigned int x;
1004
1005   for (x= 0; x < 10; x++)
1006   {
1007     rc= memcached_set(memc, key, strlen(key),
1008                       value, value_length,
1009                       (time_t)0, (uint32_t)0);
1010     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1011   }
1012
1013   return TEST_SUCCESS;
1014 }
1015
1016 static test_return_t set_test3(memcached_st *memc)
1017 {
1018   memcached_return_t rc;
1019   char *value;
1020   size_t value_length= 8191;
1021   unsigned int x;
1022
1023   value = (char*)malloc(value_length);
1024   test_true(value);
1025
1026   for (x= 0; x < value_length; x++)
1027     value[x] = (char) (x % 127);
1028
1029   /* The dump test relies on there being at least 32 items in memcached */
1030   for (x= 0; x < 32; x++)
1031   {
1032     char key[16];
1033
1034     snprintf(key, sizeof(key), "foo%u", x);
1035
1036     rc= memcached_set(memc, key, strlen(key),
1037                       value, value_length,
1038                       (time_t)0, (uint32_t)0);
1039     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1040   }
1041
1042   free(value);
1043
1044   return TEST_SUCCESS;
1045 }
1046
1047 static test_return_t get_test3(memcached_st *memc)
1048 {
1049   memcached_return_t rc;
1050   const char *key= "foo";
1051   char *value;
1052   size_t value_length= 8191;
1053   char *string;
1054   size_t string_length;
1055   uint32_t flags;
1056   uint32_t x;
1057
1058   value = (char*)malloc(value_length);
1059   test_true(value);
1060
1061   for (x= 0; x < value_length; x++)
1062     value[x] = (char) (x % 127);
1063
1064   rc= memcached_set(memc, key, strlen(key),
1065                     value, value_length,
1066                     (time_t)0, (uint32_t)0);
1067   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1068
1069   string= memcached_get(memc, key, strlen(key),
1070                         &string_length, &flags, &rc);
1071
1072   test_true(rc == MEMCACHED_SUCCESS);
1073   test_true(string);
1074   test_true(string_length == value_length);
1075   test_true(!memcmp(string, value, string_length));
1076
1077   free(string);
1078   free(value);
1079
1080   return TEST_SUCCESS;
1081 }
1082
1083 static test_return_t get_test4(memcached_st *memc)
1084 {
1085   memcached_return_t rc;
1086   const char *key= "foo";
1087   char *value;
1088   size_t value_length= 8191;
1089   char *string;
1090   size_t string_length;
1091   uint32_t flags;
1092   uint32_t x;
1093
1094   value = (char*)malloc(value_length);
1095   test_true(value);
1096
1097   for (x= 0; x < value_length; x++)
1098     value[x] = (char) (x % 127);
1099
1100   rc= memcached_set(memc, key, strlen(key),
1101                     value, value_length,
1102                     (time_t)0, (uint32_t)0);
1103   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1104
1105   for (x= 0; x < 10; x++)
1106   {
1107     string= memcached_get(memc, key, strlen(key),
1108                           &string_length, &flags, &rc);
1109
1110     test_true(rc == MEMCACHED_SUCCESS);
1111     test_true(string);
1112     test_true(string_length == value_length);
1113     test_true(!memcmp(string, value, string_length));
1114     free(string);
1115   }
1116
1117   free(value);
1118
1119   return TEST_SUCCESS;
1120 }
1121
1122 /*
1123  * This test verifies that memcached_read_one_response doesn't try to
1124  * dereference a NIL-pointer if you issue a multi-get and don't read out all
1125  * responses before you execute a storage command.
1126  */
1127 static test_return_t get_test5(memcached_st *memc)
1128 {
1129   /*
1130   ** Request the same key twice, to ensure that we hash to the same server
1131   ** (so that we have multiple response values queued up) ;-)
1132   */
1133   const char *keys[]= { "key", "key" };
1134   size_t lengths[]= { 3, 3 };
1135   uint32_t flags;
1136   size_t rlen;
1137
1138   memcached_return_t rc= memcached_set(memc, keys[0], lengths[0],
1139                                      keys[0], lengths[0], 0, 0);
1140   test_true(rc == MEMCACHED_SUCCESS);
1141   rc= memcached_mget(memc, keys, lengths, 2);
1142
1143   memcached_result_st results_obj;
1144   memcached_result_st *results;
1145   results=memcached_result_create(memc, &results_obj);
1146   test_true(results);
1147   results=memcached_fetch_result(memc, &results_obj, &rc);
1148   test_true(results);
1149   memcached_result_free(&results_obj);
1150
1151   /* Don't read out the second result, but issue a set instead.. */
1152   rc= memcached_set(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0);
1153   test_true(rc == MEMCACHED_SUCCESS);
1154
1155   char *val= memcached_get_by_key(memc, keys[0], lengths[0], "yek", 3,
1156                                   &rlen, &flags, &rc);
1157   test_true(val == NULL);
1158   test_true(rc == MEMCACHED_NOTFOUND);
1159   val= memcached_get(memc, keys[0], lengths[0], &rlen, &flags, &rc);
1160   test_true(val != NULL);
1161   test_true(rc == MEMCACHED_SUCCESS);
1162   free(val);
1163
1164   return TEST_SUCCESS;
1165 }
1166
1167 static test_return_t mget_end(memcached_st *memc)
1168 {
1169   const char *keys[]= { "foo", "foo2" };
1170   size_t lengths[]= { 3, 4 };
1171   const char *values[]= { "fjord", "41" };
1172
1173   memcached_return_t rc;
1174
1175   // Set foo and foo2
1176   for (int i= 0; i < 2; i++)
1177   {
1178     rc= memcached_set(memc, keys[i], lengths[i], values[i], strlen(values[i]),
1179                       (time_t)0, (uint32_t)0);
1180     test_true(rc == MEMCACHED_SUCCESS);
1181   }
1182
1183   char *string;
1184   size_t string_length;
1185   uint32_t flags;
1186
1187   // retrieve both via mget
1188   rc= memcached_mget(memc, keys, lengths, 2);
1189   test_true(rc == MEMCACHED_SUCCESS);
1190
1191   char key[MEMCACHED_MAX_KEY];
1192   size_t key_length;
1193
1194   // this should get both
1195   for (int i = 0; i < 2; i++)
1196   {
1197     string= memcached_fetch(memc, key, &key_length, &string_length,
1198                             &flags, &rc);
1199     test_true(rc == MEMCACHED_SUCCESS);
1200     int val = 0;
1201     if (key_length == 4)
1202       val= 1;
1203     test_true(string_length == strlen(values[val]));
1204     test_true(strncmp(values[val], string, string_length) == 0);
1205     free(string);
1206   }
1207
1208   // this should indicate end
1209   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1210   test_true(rc == MEMCACHED_END);
1211
1212   // now get just one
1213   rc= memcached_mget(memc, keys, lengths, 1);
1214   test_true(rc == MEMCACHED_SUCCESS);
1215
1216   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1217   test_true(key_length == lengths[0]);
1218   test_true(strncmp(keys[0], key, key_length) == 0);
1219   test_true(string_length == strlen(values[0]));
1220   test_true(strncmp(values[0], string, string_length) == 0);
1221   test_true(rc == MEMCACHED_SUCCESS);
1222   free(string);
1223
1224   // this should indicate end
1225   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1226   test_true(rc == MEMCACHED_END);
1227
1228   return TEST_SUCCESS;
1229 }
1230
1231 /* Do not copy the style of this code, I just access hosts to testthis function */
1232 static test_return_t stats_servername_test(memcached_st *memc)
1233 {
1234   memcached_return_t rc;
1235   memcached_stat_st memc_stat;
1236   memcached_server_instance_st instance=
1237     memcached_server_instance_by_position(memc, 0);
1238
1239 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
1240   if (memcached_get_sasl_callbacks(memc) != NULL)
1241     return TEST_SKIPPED;
1242 #endif
1243   rc= memcached_stat_servername(&memc_stat, NULL,
1244                                 memcached_server_name(instance),
1245                                 memcached_server_port(instance));
1246
1247   return TEST_SUCCESS;
1248 }
1249
1250 static test_return_t increment_test(memcached_st *memc)
1251 {
1252   uint64_t new_number;
1253   memcached_return_t rc;
1254   const char *key= "number";
1255   const char *value= "0";
1256
1257   rc= memcached_set(memc, key, strlen(key),
1258                     value, strlen(value),
1259                     (time_t)0, (uint32_t)0);
1260   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1261
1262   rc= memcached_increment(memc, key, strlen(key),
1263                           1, &new_number);
1264   test_true(rc == MEMCACHED_SUCCESS);
1265   test_true(new_number == 1);
1266
1267   rc= memcached_increment(memc, key, strlen(key),
1268                           1, &new_number);
1269   test_true(rc == MEMCACHED_SUCCESS);
1270   test_true(new_number == 2);
1271
1272   return TEST_SUCCESS;
1273 }
1274
1275 static test_return_t increment_with_initial_test(memcached_st *memc)
1276 {
1277   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1278   {
1279     uint64_t new_number;
1280     memcached_return_t rc;
1281     const char *key= "number";
1282     uint64_t initial= 0;
1283
1284     rc= memcached_increment_with_initial(memc, key, strlen(key),
1285                                          1, initial, 0, &new_number);
1286     test_true(rc == MEMCACHED_SUCCESS);
1287     test_true(new_number == initial);
1288
1289     rc= memcached_increment_with_initial(memc, key, strlen(key),
1290                                          1, initial, 0, &new_number);
1291     test_true(rc == MEMCACHED_SUCCESS);
1292     test_true(new_number == (initial + 1));
1293   }
1294   return TEST_SUCCESS;
1295 }
1296
1297 static test_return_t decrement_test(memcached_st *memc)
1298 {
1299   uint64_t new_number;
1300   memcached_return_t rc;
1301   const char *key= "number";
1302   const char *value= "3";
1303
1304   rc= memcached_set(memc, key, strlen(key),
1305                     value, strlen(value),
1306                     (time_t)0, (uint32_t)0);
1307   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1308
1309   rc= memcached_decrement(memc, key, strlen(key),
1310                           1, &new_number);
1311   test_true(rc == MEMCACHED_SUCCESS);
1312   test_true(new_number == 2);
1313
1314   rc= memcached_decrement(memc, key, strlen(key),
1315                           1, &new_number);
1316   test_true(rc == MEMCACHED_SUCCESS);
1317   test_true(new_number == 1);
1318
1319   return TEST_SUCCESS;
1320 }
1321
1322 static test_return_t decrement_with_initial_test(memcached_st *memc)
1323 {
1324   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1325   {
1326     uint64_t new_number;
1327     memcached_return_t rc;
1328     const char *key= "number";
1329     uint64_t initial= 3;
1330
1331     rc= memcached_decrement_with_initial(memc, key, strlen(key),
1332                                          1, initial, 0, &new_number);
1333     test_true(rc == MEMCACHED_SUCCESS);
1334     test_true(new_number == initial);
1335
1336     rc= memcached_decrement_with_initial(memc, key, strlen(key),
1337                                          1, initial, 0, &new_number);
1338     test_true(rc == MEMCACHED_SUCCESS);
1339     test_true(new_number == (initial - 1));
1340   }
1341   return TEST_SUCCESS;
1342 }
1343
1344 static test_return_t increment_by_key_test(memcached_st *memc)
1345 {
1346   uint64_t new_number;
1347   memcached_return_t rc;
1348   const char *master_key= "foo";
1349   const char *key= "number";
1350   const char *value= "0";
1351
1352   rc= memcached_set_by_key(memc, master_key, strlen(master_key),
1353                            key, strlen(key),
1354                            value, strlen(value),
1355                            (time_t)0, (uint32_t)0);
1356   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1357
1358   rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
1359                                  1, &new_number);
1360   test_true(rc == MEMCACHED_SUCCESS);
1361   test_true(new_number == 1);
1362
1363   rc= memcached_increment_by_key(memc, master_key, strlen(master_key), key, strlen(key),
1364                                  1, &new_number);
1365   test_true(rc == MEMCACHED_SUCCESS);
1366   test_true(new_number == 2);
1367
1368   return TEST_SUCCESS;
1369 }
1370
1371 static test_return_t increment_with_initial_by_key_test(memcached_st *memc)
1372 {
1373   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1374   {
1375     uint64_t new_number;
1376     memcached_return_t rc;
1377     const char *master_key= "foo";
1378     const char *key= "number";
1379     uint64_t initial= 0;
1380
1381     rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1382                                                 key, strlen(key),
1383                                                 1, initial, 0, &new_number);
1384     test_true(rc == MEMCACHED_SUCCESS);
1385     test_true(new_number == initial);
1386
1387     rc= memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1388                                                 key, strlen(key),
1389                                                 1, initial, 0, &new_number);
1390     test_true(rc == MEMCACHED_SUCCESS);
1391     test_true(new_number == (initial + 1));
1392   }
1393   return TEST_SUCCESS;
1394 }
1395
1396 static test_return_t decrement_by_key_test(memcached_st *memc)
1397 {
1398   uint64_t new_number;
1399   memcached_return_t rc;
1400   const char *master_key= "foo";
1401   const char *key= "number";
1402   const char *value= "3";
1403
1404   rc= memcached_set_by_key(memc, master_key, strlen(master_key),
1405                            key, strlen(key),
1406                            value, strlen(value),
1407                            (time_t)0, (uint32_t)0);
1408   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1409
1410   rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
1411                                  key, strlen(key),
1412                                  1, &new_number);
1413   test_true(rc == MEMCACHED_SUCCESS);
1414   test_true(new_number == 2);
1415
1416   rc= memcached_decrement_by_key(memc, master_key, strlen(master_key),
1417                                  key, strlen(key),
1418                                  1, &new_number);
1419   test_true(rc == MEMCACHED_SUCCESS);
1420   test_true(new_number == 1);
1421
1422   return TEST_SUCCESS;
1423 }
1424
1425 static test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
1426 {
1427   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1428   {
1429     uint64_t new_number;
1430     memcached_return_t rc;
1431     const char *master_key= "foo";
1432     const char *key= "number";
1433     uint64_t initial= 3;
1434
1435     rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
1436                                                 key, strlen(key),
1437                                                 1, initial, 0, &new_number);
1438     test_true(rc == MEMCACHED_SUCCESS);
1439     test_true(new_number == initial);
1440
1441     rc= memcached_decrement_with_initial_by_key(memc, master_key, strlen(master_key),
1442                                                 key, strlen(key),
1443                                                 1, initial, 0, &new_number);
1444     test_true(rc == MEMCACHED_SUCCESS);
1445     test_true(new_number == (initial - 1));
1446   }
1447   return TEST_SUCCESS;
1448 }
1449
1450 static test_return_t quit_test(memcached_st *memc)
1451 {
1452   memcached_return_t rc;
1453   const char *key= "fudge";
1454   const char *value= "sanford and sun";
1455
1456   rc= memcached_set(memc, key, strlen(key),
1457                     value, strlen(value),
1458                     (time_t)10, (uint32_t)3);
1459   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1460   memcached_quit(memc);
1461
1462   rc= memcached_set(memc, key, strlen(key),
1463                     value, strlen(value),
1464                     (time_t)50, (uint32_t)9);
1465   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1466
1467   return TEST_SUCCESS;
1468 }
1469
1470 static test_return_t mget_result_test(memcached_st *memc)
1471 {
1472   memcached_return_t rc;
1473   const char *keys[]= {"fudge", "son", "food"};
1474   size_t key_length[]= {5, 3, 4};
1475   unsigned int x;
1476
1477   memcached_result_st results_obj;
1478   memcached_result_st *results;
1479
1480   results= memcached_result_create(memc, &results_obj);
1481   test_true(results);
1482   test_true(&results_obj == results);
1483
1484   /* We need to empty the server before continueing test */
1485   rc= memcached_flush(memc, 0);
1486   test_true(rc == MEMCACHED_SUCCESS);
1487
1488   rc= memcached_mget(memc, keys, key_length, 3);
1489   test_true(rc == MEMCACHED_SUCCESS);
1490
1491   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1492   {
1493     test_true(results);
1494   }
1495
1496   while ((results= memcached_fetch_result(memc, &results_obj, &rc)) != NULL)
1497   test_true(!results);
1498   test_true(rc == MEMCACHED_END);
1499
1500   for (x= 0; x < 3; x++)
1501   {
1502     rc= memcached_set(memc, keys[x], key_length[x],
1503                       keys[x], key_length[x],
1504                       (time_t)50, (uint32_t)9);
1505     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1506   }
1507
1508   rc= memcached_mget(memc, keys, key_length, 3);
1509   test_true(rc == MEMCACHED_SUCCESS);
1510
1511   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1512   {
1513     test_true(results);
1514     test_true(&results_obj == results);
1515     test_true(rc == MEMCACHED_SUCCESS);
1516     test_true(memcached_result_key_length(results) == memcached_result_length(results));
1517     test_true(!memcmp(memcached_result_key_value(results),
1518                    memcached_result_value(results),
1519                    memcached_result_length(results)));
1520   }
1521
1522   memcached_result_free(&results_obj);
1523
1524   return TEST_SUCCESS;
1525 }
1526
1527 static test_return_t mget_result_alloc_test(memcached_st *memc)
1528 {
1529   memcached_return_t rc;
1530   const char *keys[]= {"fudge", "son", "food"};
1531   size_t key_length[]= {5, 3, 4};
1532   unsigned int x;
1533
1534   memcached_result_st *results;
1535
1536   /* We need to empty the server before continueing test */
1537   rc= memcached_flush(memc, 0);
1538   test_true(rc == MEMCACHED_SUCCESS);
1539
1540   rc= memcached_mget(memc, keys, key_length, 3);
1541   test_true(rc == MEMCACHED_SUCCESS);
1542
1543   while ((results= memcached_fetch_result(memc, NULL, &rc)) != NULL)
1544   {
1545     test_true(results);
1546   }
1547   test_true(!results);
1548   test_true(rc == MEMCACHED_END);
1549
1550   for (x= 0; x < 3; x++)
1551   {
1552     rc= memcached_set(memc, keys[x], key_length[x],
1553                       keys[x], key_length[x],
1554                       (time_t)50, (uint32_t)9);
1555     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1556   }
1557
1558   rc= memcached_mget(memc, keys, key_length, 3);
1559   test_true(rc == MEMCACHED_SUCCESS);
1560
1561   x= 0;
1562   while ((results= memcached_fetch_result(memc, NULL, &rc)))
1563   {
1564     test_true(results);
1565     test_true(rc == MEMCACHED_SUCCESS);
1566     test_true(memcached_result_key_length(results) == memcached_result_length(results));
1567     test_true(!memcmp(memcached_result_key_value(results),
1568                    memcached_result_value(results),
1569                    memcached_result_length(results)));
1570     memcached_result_free(results);
1571     x++;
1572   }
1573
1574   return TEST_SUCCESS;
1575 }
1576
1577 /* Count the results */
1578 static memcached_return_t callback_counter(const memcached_st *ptr __attribute__((unused)),
1579                                            memcached_result_st *result __attribute__((unused)),
1580                                            void *context)
1581 {
1582   size_t *counter= (size_t *)context;
1583
1584   *counter= *counter + 1;
1585
1586   return MEMCACHED_SUCCESS;
1587 }
1588
1589 static test_return_t mget_result_function(memcached_st *memc)
1590 {
1591   memcached_return_t rc;
1592   const char *keys[]= {"fudge", "son", "food"};
1593   size_t key_length[]= {5, 3, 4};
1594   unsigned int x;
1595   size_t counter;
1596   memcached_execute_fn callbacks[1];
1597
1598   /* We need to empty the server before continueing test */
1599   rc= memcached_flush(memc, 0);
1600   for (x= 0; x < 3; x++)
1601   {
1602     rc= memcached_set(memc, keys[x], key_length[x],
1603                       keys[x], key_length[x],
1604                       (time_t)50, (uint32_t)9);
1605     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1606   }
1607
1608   rc= memcached_mget(memc, keys, key_length, 3);
1609   test_true(rc == MEMCACHED_SUCCESS);
1610
1611   callbacks[0]= &callback_counter;
1612   counter= 0;
1613   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1614
1615   test_true(counter == 3);
1616
1617   return TEST_SUCCESS;
1618 }
1619
1620 static test_return_t mget_test(memcached_st *memc)
1621 {
1622   memcached_return_t rc;
1623   const char *keys[]= {"fudge", "son", "food"};
1624   size_t key_length[]= {5, 3, 4};
1625   unsigned int x;
1626   uint32_t flags;
1627
1628   char return_key[MEMCACHED_MAX_KEY];
1629   size_t return_key_length;
1630   char *return_value;
1631   size_t return_value_length;
1632
1633   /* We need to empty the server before continueing test */
1634   rc= memcached_flush(memc, 0);
1635   test_true(rc == MEMCACHED_SUCCESS);
1636
1637   rc= memcached_mget(memc, keys, key_length, 3);
1638   test_true(rc == MEMCACHED_SUCCESS);
1639
1640   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1641                       &return_value_length, &flags, &rc)) != NULL)
1642   {
1643     test_true(return_value);
1644   }
1645   test_true(!return_value);
1646   test_true(return_value_length == 0);
1647   test_true(rc == MEMCACHED_END);
1648
1649   for (x= 0; x < 3; x++)
1650   {
1651     rc= memcached_set(memc, keys[x], key_length[x],
1652                       keys[x], key_length[x],
1653                       (time_t)50, (uint32_t)9);
1654     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1655   }
1656
1657   rc= memcached_mget(memc, keys, key_length, 3);
1658   test_true(rc == MEMCACHED_SUCCESS);
1659
1660   x= 0;
1661   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1662                                         &return_value_length, &flags, &rc)))
1663   {
1664     test_true(return_value);
1665     test_true(rc == MEMCACHED_SUCCESS);
1666     test_true(return_key_length == return_value_length);
1667     test_true(!memcmp(return_value, return_key, return_value_length));
1668     free(return_value);
1669     x++;
1670   }
1671
1672   return TEST_SUCCESS;
1673 }
1674
1675 static test_return_t mget_execute(memcached_st *memc)
1676 {
1677   bool binary= false;
1678
1679   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) != 0)
1680     binary= true;
1681
1682   /*
1683    * I only want to hit _one_ server so I know the number of requests I'm
1684    * sending in the pipeline.
1685    */
1686   uint32_t number_of_hosts= memc->number_of_hosts;
1687   memc->number_of_hosts= 1;
1688
1689   size_t max_keys= 20480;
1690
1691
1692   char **keys= calloc(max_keys, sizeof(char*));
1693   size_t *key_length=calloc(max_keys, sizeof(size_t));
1694
1695   /* First add all of the items.. */
1696   char blob[1024] = {0};
1697   memcached_return_t rc;
1698
1699   for (size_t x= 0; x < max_keys; ++x)
1700   {
1701     char k[251];
1702
1703     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
1704     keys[x]= strdup(k);
1705     test_true(keys[x] != NULL);
1706     rc= memcached_add(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
1707     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1708   }
1709
1710   /* Try to get all of them with a large multiget */
1711   size_t counter= 0;
1712   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
1713   rc= memcached_mget_execute(memc, (const char**)keys, key_length,
1714                              max_keys, callbacks, &counter, 1);
1715
1716   if (rc == MEMCACHED_SUCCESS)
1717   {
1718     test_true(binary);
1719     rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
1720     test_true(rc == MEMCACHED_END);
1721
1722     /* Verify that we got all of the items */
1723     test_true(counter == max_keys);
1724   }
1725   else if (rc == MEMCACHED_NOT_SUPPORTED)
1726   {
1727     test_true(counter == 0);
1728   }
1729   else
1730   {
1731     test_fail("note: this test functions differently when in binary mode");
1732   }
1733
1734   /* Release all allocated resources */
1735   for (size_t x= 0; x < max_keys; ++x)
1736   {
1737     free(keys[x]);
1738   }
1739   free(keys);
1740   free(key_length);
1741
1742   memc->number_of_hosts= number_of_hosts;
1743   return TEST_SUCCESS;
1744 }
1745
1746 #define REGRESSION_BINARY_VS_BLOCK_COUNT  20480
1747
1748 static test_return_t key_setup(memcached_st *memc)
1749 {
1750   (void)memc;
1751
1752   if (pre_binary(memc) != TEST_SUCCESS)
1753     return TEST_SKIPPED;
1754
1755   global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
1756
1757   return TEST_SUCCESS;
1758 }
1759
1760 static test_return_t key_teardown(memcached_st *memc)
1761 {
1762   (void)memc;
1763   pairs_free(global_pairs);
1764
1765   return TEST_SUCCESS;
1766 }
1767
1768 static test_return_t block_add_regression(memcached_st *memc)
1769 {
1770   /* First add all of the items.. */
1771   for (size_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)
1772   {
1773     memcached_return_t rc;
1774     char blob[1024] = {0};
1775
1776     rc= memcached_add_by_key(memc, "bob", 3, global_pairs[x].key, global_pairs[x].key_length, blob, sizeof(blob), 0, 0);
1777     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
1778   }
1779
1780   return TEST_SUCCESS;
1781 }
1782
1783 static test_return_t binary_add_regression(memcached_st *memc)
1784 {
1785   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
1786   test_return_t rc= block_add_regression(memc);
1787   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 0);
1788   return rc;
1789 }
1790
1791 static test_return_t get_stats_keys(memcached_st *memc)
1792 {
1793  char **stat_list;
1794  char **ptr;
1795  memcached_stat_st memc_stat;
1796  memcached_return_t rc;
1797
1798  stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
1799  test_true(rc == MEMCACHED_SUCCESS);
1800  for (ptr= stat_list; *ptr; ptr++)
1801    test_true(*ptr);
1802
1803  free(stat_list);
1804
1805  return TEST_SUCCESS;
1806 }
1807
1808 static test_return_t version_string_test(memcached_st *memc __attribute__((unused)))
1809 {
1810   const char *version_string;
1811
1812   version_string= memcached_lib_version();
1813
1814   test_true(!strcmp(version_string, LIBMEMCACHED_VERSION_STRING));
1815
1816   return TEST_SUCCESS;
1817 }
1818
1819 static test_return_t get_stats(memcached_st *memc)
1820 {
1821  char **stat_list;
1822  char **ptr;
1823  memcached_return_t rc;
1824  memcached_stat_st *memc_stat;
1825
1826  memc_stat= memcached_stat(memc, NULL, &rc);
1827  test_true(rc == MEMCACHED_SUCCESS);
1828
1829  test_true(rc == MEMCACHED_SUCCESS);
1830  test_true(memc_stat);
1831
1832  for (uint32_t x= 0; x < memcached_server_count(memc); x++)
1833  {
1834    stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
1835    test_true(rc == MEMCACHED_SUCCESS);
1836    for (ptr= stat_list; *ptr; ptr++);
1837
1838    free(stat_list);
1839  }
1840
1841  memcached_stat_free(NULL, memc_stat);
1842
1843   return TEST_SUCCESS;
1844 }
1845
1846 static test_return_t add_host_test(memcached_st *memc)
1847 {
1848   unsigned int x;
1849   memcached_server_st *servers;
1850   memcached_return_t rc;
1851   char servername[]= "0.example.com";
1852
1853   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1854   test_true(servers);
1855   test_true(1 == memcached_server_list_count(servers));
1856
1857   for (x= 2; x < 20; x++)
1858   {
1859     char buffer[SMALL_STRING_LEN];
1860
1861     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1862     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1863                                      &rc);
1864     test_true(rc == MEMCACHED_SUCCESS);
1865     test_true(x == memcached_server_list_count(servers));
1866   }
1867
1868   rc= memcached_server_push(memc, servers);
1869   test_true(rc == MEMCACHED_SUCCESS);
1870   rc= memcached_server_push(memc, servers);
1871   test_true(rc == MEMCACHED_SUCCESS);
1872
1873   memcached_server_list_free(servers);
1874
1875   return TEST_SUCCESS;
1876 }
1877
1878 static memcached_return_t  clone_test_callback(memcached_st *parent __attribute__((unused)), memcached_st *memc_clone __attribute__((unused)))
1879 {
1880   return MEMCACHED_SUCCESS;
1881 }
1882
1883 static memcached_return_t  cleanup_test_callback(memcached_st *ptr __attribute__((unused)))
1884 {
1885   return MEMCACHED_SUCCESS;
1886 }
1887
1888 static test_return_t callback_test(memcached_st *memc)
1889 {
1890   /* Test User Data */
1891   {
1892     int x= 5;
1893     int *test_ptr;
1894     memcached_return_t rc;
1895
1896     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x);
1897     test_true(rc == MEMCACHED_SUCCESS);
1898     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
1899     test_true(*test_ptr == x);
1900   }
1901
1902   /* Test Clone Callback */
1903   {
1904     memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
1905     void *clone_cb_ptr= *(void **)&clone_cb;
1906     void *temp_function= NULL;
1907     memcached_return_t rc;
1908
1909     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1910                                clone_cb_ptr);
1911     test_true(rc == MEMCACHED_SUCCESS);
1912     temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1913     test_true(temp_function == clone_cb_ptr);
1914   }
1915
1916   /* Test Cleanup Callback */
1917   {
1918     memcached_cleanup_fn cleanup_cb=
1919       (memcached_cleanup_fn)cleanup_test_callback;
1920     void *cleanup_cb_ptr= *(void **)&cleanup_cb;
1921     void *temp_function= NULL;
1922     memcached_return_t rc;
1923
1924     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION,
1925                                cleanup_cb_ptr);
1926     test_true(rc == MEMCACHED_SUCCESS);
1927     temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
1928     test_true(temp_function == cleanup_cb_ptr);
1929   }
1930
1931   return TEST_SUCCESS;
1932 }
1933
1934 /* We don't test the behavior itself, we test the switches */
1935 static test_return_t behavior_test(memcached_st *memc)
1936 {
1937   uint64_t value;
1938   uint32_t set= 1;
1939
1940   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1941   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1942   test_true(value == 1);
1943
1944   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1945   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1946   test_true(value == 1);
1947
1948   set= MEMCACHED_HASH_MD5;
1949   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1950   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1951   test_true(value == MEMCACHED_HASH_MD5);
1952
1953   set= 0;
1954
1955   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
1956   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK);
1957   test_true(value == 0);
1958
1959   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
1960   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY);
1961   test_true(value == 0);
1962
1963   set= MEMCACHED_HASH_DEFAULT;
1964   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1965   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1966   test_true(value == MEMCACHED_HASH_DEFAULT);
1967
1968   set= MEMCACHED_HASH_CRC;
1969   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, set);
1970   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
1971   test_true(value == MEMCACHED_HASH_CRC);
1972
1973   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
1974   test_true(value > 0);
1975
1976   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
1977   test_true(value > 0);
1978
1979   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
1980   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value + 1);
1981   test_true((value + 1) == memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
1982
1983   return TEST_SUCCESS;
1984 }
1985
1986 static test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
1987 {
1988   memcached_return_t rc;
1989   bool set= true;
1990   bool value;
1991
1992   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
1993   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
1994
1995   value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
1996
1997   if (rc == MEMCACHED_SUCCESS)
1998   {
1999     test_true((bool)value == set);
2000   }
2001   else
2002   {
2003     test_false((bool)value == set);
2004   }
2005
2006   return TEST_SUCCESS;
2007 }
2008
2009
2010 static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
2011 {
2012   memcached_return_t rc;
2013   bool set= true;
2014   bool value;
2015
2016   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, set);
2017   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
2018
2019   value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
2020
2021   if (rc == MEMCACHED_SUCCESS)
2022   {
2023     test_true((bool)value == set);
2024   }
2025   else
2026   {
2027     test_false((bool)value == set);
2028   }
2029
2030   return TEST_SUCCESS;
2031 }
2032
2033
2034 static test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
2035 {
2036   memcached_return_t rc;
2037   bool set= true;
2038   bool value;
2039
2040   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, set);
2041   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
2042
2043   value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
2044
2045   if (rc == MEMCACHED_SUCCESS)
2046   {
2047     test_true((bool)value == set);
2048   }
2049   else
2050   {
2051     test_false((bool)value == set);
2052   }
2053
2054   return TEST_SUCCESS;
2055 }
2056
2057 static test_return_t fetch_all_results(memcached_st *memc, size_t *keys_returned)
2058 {
2059   memcached_return_t rc= MEMCACHED_SUCCESS;
2060   char return_key[MEMCACHED_MAX_KEY];
2061   size_t return_key_length;
2062   char *return_value;
2063   size_t return_value_length;
2064   uint32_t flags;
2065
2066   *keys_returned= 0;
2067
2068   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2069                                         &return_value_length, &flags, &rc)))
2070   {
2071     test_true(return_value);
2072     test_true(rc == MEMCACHED_SUCCESS);
2073     free(return_value);
2074     *keys_returned= *keys_returned +1;
2075   }
2076
2077   test_true_got(rc == MEMCACHED_END || rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
2078
2079   return TEST_SUCCESS;
2080 }
2081
2082 /* Test case provided by Cal Haldenbrand */
2083 static test_return_t user_supplied_bug1(memcached_st *memc)
2084 {
2085   unsigned int setter= 1;
2086
2087   unsigned long long total= 0;
2088   uint32_t size= 0;
2089   char key[10];
2090   char randomstuff[6 * 1024];
2091   memcached_return_t rc;
2092
2093   memset(randomstuff, 0, 6 * 1024);
2094
2095   /* We just keep looking at the same values over and over */
2096   srandom(10);
2097
2098   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
2099   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2100
2101
2102   /* add key */
2103   for (uint32_t x= 0 ; total < 20 * 1024576 ; x++ )
2104   {
2105     unsigned int j= 0;
2106
2107     size= (uint32_t)(rand() % ( 5 * 1024 ) ) + 400;
2108     memset(randomstuff, 0, 6 * 1024);
2109     test_true(size < 6 * 1024); /* Being safe here */
2110
2111     for (j= 0 ; j < size ;j++)
2112       randomstuff[j] = (signed char) ((rand() % 26) + 97);
2113
2114     total += size;
2115     snprintf(key, sizeof(key), "%u", x);
2116     rc = memcached_set(memc, key, strlen(key),
2117                        randomstuff, strlen(randomstuff), 10, 0);
2118     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2119     /* If we fail, lets try again */
2120     if (rc != MEMCACHED_SUCCESS && rc != MEMCACHED_BUFFERED)
2121       rc = memcached_set(memc, key, strlen(key),
2122                          randomstuff, strlen(randomstuff), 10, 0);
2123     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2124   }
2125
2126   return TEST_SUCCESS;
2127 }
2128
2129 /* Test case provided by Cal Haldenbrand */
2130 static test_return_t user_supplied_bug2(memcached_st *memc)
2131 {
2132   unsigned int setter;
2133   size_t total= 0;
2134
2135   setter= 1;
2136   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
2137   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2138 #ifdef NOT_YET
2139   setter = 20 * 1024576;
2140   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
2141   setter = 20 * 1024576;
2142   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
2143   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
2144   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
2145
2146   for (x= 0, errors= 0; total < 20 * 1024576 ; x++)
2147 #endif
2148
2149   for (uint32_t x= 0, errors= 0; total < 24576 ; x++)
2150   {
2151     memcached_return_t rc= MEMCACHED_SUCCESS;
2152     char buffer[SMALL_STRING_LEN];
2153     uint32_t flags= 0;
2154     size_t val_len= 0;
2155     char *getval;
2156
2157     memset(buffer, 0, SMALL_STRING_LEN);
2158
2159     snprintf(buffer, sizeof(buffer), "%u", x);
2160     getval= memcached_get(memc, buffer, strlen(buffer),
2161                            &val_len, &flags, &rc);
2162     if (rc != MEMCACHED_SUCCESS)
2163     {
2164       if (rc == MEMCACHED_NOTFOUND)
2165         errors++;
2166       else
2167       {
2168         test_true(rc);
2169       }
2170
2171       continue;
2172     }
2173     total+= val_len;
2174     errors= 0;
2175     free(getval);
2176   }
2177
2178   return TEST_SUCCESS;
2179 }
2180
2181 /* Do a large mget() over all the keys we think exist */
2182 #define KEY_COUNT 3000 // * 1024576
2183 static test_return_t user_supplied_bug3(memcached_st *memc)
2184 {
2185   memcached_return_t rc;
2186   unsigned int setter;
2187   unsigned int x;
2188   char **keys;
2189   size_t key_lengths[KEY_COUNT];
2190
2191   setter= 1;
2192   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, setter);
2193   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2194 #ifdef NOT_YET
2195   setter = 20 * 1024576;
2196   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE, setter);
2197   setter = 20 * 1024576;
2198   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE, setter);
2199   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE);
2200   getter = memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE);
2201 #endif
2202
2203   keys= calloc(KEY_COUNT, sizeof(char *));
2204   test_true(keys);
2205   for (x= 0; x < KEY_COUNT; x++)
2206   {
2207     char buffer[30];
2208
2209     snprintf(buffer, 30, "%u", x);
2210     keys[x]= strdup(buffer);
2211     key_lengths[x]= strlen(keys[x]);
2212   }
2213
2214   rc= memcached_mget(memc, (const char **)keys, key_lengths, KEY_COUNT);
2215   test_true(rc == MEMCACHED_SUCCESS);
2216
2217   size_t keys_returned;
2218   test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
2219
2220   for (x= 0; x < KEY_COUNT; x++)
2221     free(keys[x]);
2222   free(keys);
2223
2224   return TEST_SUCCESS;
2225 }
2226
2227 /* Make sure we behave properly if server list has no values */
2228 static test_return_t user_supplied_bug4(memcached_st *memc)
2229 {
2230   memcached_return_t rc;
2231   const char *keys[]= {"fudge", "son", "food"};
2232   size_t key_length[]= {5, 3, 4};
2233   unsigned int x;
2234   uint32_t flags;
2235   char return_key[MEMCACHED_MAX_KEY];
2236   size_t return_key_length;
2237   char *return_value;
2238   size_t return_value_length;
2239
2240   /* Here we free everything before running a bunch of mget tests */
2241   memcached_servers_reset(memc);
2242
2243
2244   /* We need to empty the server before continueing test */
2245   rc= memcached_flush(memc, 0);
2246   test_true(rc == MEMCACHED_NO_SERVERS);
2247
2248   rc= memcached_mget(memc, keys, key_length, 3);
2249   test_true(rc == MEMCACHED_NO_SERVERS);
2250
2251   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2252                       &return_value_length, &flags, &rc)) != NULL)
2253   {
2254     test_true(return_value);
2255   }
2256   test_true(!return_value);
2257   test_true(return_value_length == 0);
2258   test_true(rc == MEMCACHED_NO_SERVERS);
2259
2260   for (x= 0; x < 3; x++)
2261   {
2262     rc= memcached_set(memc, keys[x], key_length[x],
2263                       keys[x], key_length[x],
2264                       (time_t)50, (uint32_t)9);
2265     test_true(rc == MEMCACHED_NO_SERVERS);
2266   }
2267
2268   rc= memcached_mget(memc, keys, key_length, 3);
2269   test_true(rc == MEMCACHED_NO_SERVERS);
2270
2271   x= 0;
2272   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2273                                         &return_value_length, &flags, &rc)))
2274   {
2275     test_true(return_value);
2276     test_true(rc == MEMCACHED_SUCCESS);
2277     test_true(return_key_length == return_value_length);
2278     test_true(!memcmp(return_value, return_key, return_value_length));
2279     free(return_value);
2280     x++;
2281   }
2282
2283   return TEST_SUCCESS;
2284 }
2285
2286 #define VALUE_SIZE_BUG5 1048064
2287 static test_return_t user_supplied_bug5(memcached_st *memc)
2288 {
2289   memcached_return_t rc;
2290   const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2291   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2292   char return_key[MEMCACHED_MAX_KEY];
2293   size_t return_key_length;
2294   char *value;
2295   size_t value_length;
2296   uint32_t flags;
2297   unsigned int count;
2298   unsigned int x;
2299   char insert_data[VALUE_SIZE_BUG5];
2300
2301   for (x= 0; x < VALUE_SIZE_BUG5; x++)
2302     insert_data[x]= (signed char)rand();
2303
2304   memcached_flush(memc, 0);
2305   value= memcached_get(memc, keys[0], key_length[0],
2306                         &value_length, &flags, &rc);
2307   test_true(value == NULL);
2308   rc= memcached_mget(memc, keys, key_length, 4);
2309
2310   count= 0;
2311   while ((value= memcached_fetch(memc, return_key, &return_key_length,
2312                                         &value_length, &flags, &rc)))
2313     count++;
2314   test_true(count == 0);
2315
2316   for (x= 0; x < 4; x++)
2317   {
2318     rc= memcached_set(memc, keys[x], key_length[x],
2319                       insert_data, VALUE_SIZE_BUG5,
2320                       (time_t)0, (uint32_t)0);
2321     test_true(rc == MEMCACHED_SUCCESS);
2322   }
2323
2324   for (x= 0; x < 10; x++)
2325   {
2326     value= memcached_get(memc, keys[0], key_length[0],
2327                          &value_length, &flags, &rc);
2328     test_true(value);
2329     free(value);
2330
2331     rc= memcached_mget(memc, keys, key_length, 4);
2332     count= 0;
2333     while ((value= memcached_fetch(memc, return_key, &return_key_length,
2334                                           &value_length, &flags, &rc)))
2335     {
2336       count++;
2337       free(value);
2338     }
2339     test_true(count == 4);
2340   }
2341
2342   return TEST_SUCCESS;
2343 }
2344
2345 static test_return_t user_supplied_bug6(memcached_st *memc)
2346 {
2347   memcached_return_t rc;
2348   const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2349   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2350   char return_key[MEMCACHED_MAX_KEY];
2351   size_t return_key_length;
2352   char *value;
2353   size_t value_length;
2354   uint32_t flags;
2355   unsigned int count;
2356   unsigned int x;
2357   char insert_data[VALUE_SIZE_BUG5];
2358
2359   for (x= 0; x < VALUE_SIZE_BUG5; x++)
2360     insert_data[x]= (signed char)rand();
2361
2362   memcached_flush(memc, 0);
2363   value= memcached_get(memc, keys[0], key_length[0],
2364                         &value_length, &flags, &rc);
2365   test_true(value == NULL);
2366   test_true(rc == MEMCACHED_NOTFOUND);
2367   rc= memcached_mget(memc, keys, key_length, 4);
2368   test_true(rc == MEMCACHED_SUCCESS);
2369
2370   count= 0;
2371   while ((value= memcached_fetch(memc, return_key, &return_key_length,
2372                                         &value_length, &flags, &rc)))
2373     count++;
2374   test_true(count == 0);
2375   test_true(rc == MEMCACHED_END);
2376
2377   for (x= 0; x < 4; x++)
2378   {
2379     rc= memcached_set(memc, keys[x], key_length[x],
2380                       insert_data, VALUE_SIZE_BUG5,
2381                       (time_t)0, (uint32_t)0);
2382     test_true(rc == MEMCACHED_SUCCESS);
2383   }
2384
2385   for (x= 0; x < 2; x++)
2386   {
2387     value= memcached_get(memc, keys[0], key_length[0],
2388                          &value_length, &flags, &rc);
2389     test_true(value);
2390     free(value);
2391
2392     rc= memcached_mget(memc, keys, key_length, 4);
2393     test_true(rc == MEMCACHED_SUCCESS);
2394     count= 3;
2395     /* We test for purge of partial complete fetches */
2396     for (count= 3; count; count--)
2397     {
2398       value= memcached_fetch(memc, return_key, &return_key_length,
2399                              &value_length, &flags, &rc);
2400       test_true(rc == MEMCACHED_SUCCESS);
2401       test_true(!(memcmp(value, insert_data, value_length)));
2402       test_true(value_length);
2403       free(value);
2404     }
2405   }
2406
2407   return TEST_SUCCESS;
2408 }
2409
2410 static test_return_t user_supplied_bug8(memcached_st *memc __attribute__((unused)))
2411 {
2412   memcached_return_t rc;
2413   memcached_st *mine;
2414   memcached_st *memc_clone;
2415
2416   memcached_server_st *servers;
2417   const 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";
2418
2419   servers= memcached_servers_parse(server_list);
2420   test_true(servers);
2421
2422   mine= memcached_create(NULL);
2423   rc= memcached_server_push(mine, servers);
2424   test_true(rc == MEMCACHED_SUCCESS);
2425   memcached_server_list_free(servers);
2426
2427   test_true(mine);
2428   memc_clone= memcached_clone(NULL, mine);
2429
2430   memcached_quit(mine);
2431   memcached_quit(memc_clone);
2432
2433
2434   memcached_free(mine);
2435   memcached_free(memc_clone);
2436
2437   return TEST_SUCCESS;
2438 }
2439
2440 /* Test flag store/retrieve */
2441 static test_return_t user_supplied_bug7(memcached_st *memc)
2442 {
2443   memcached_return_t rc;
2444   const char *keys= "036790384900";
2445   size_t key_length=  strlen(keys);
2446   char return_key[MEMCACHED_MAX_KEY];
2447   size_t return_key_length;
2448   char *value;
2449   size_t value_length;
2450   uint32_t flags;
2451   unsigned int x;
2452   char insert_data[VALUE_SIZE_BUG5];
2453
2454   for (x= 0; x < VALUE_SIZE_BUG5; x++)
2455     insert_data[x]= (signed char)rand();
2456
2457   memcached_flush(memc, 0);
2458
2459   flags= 245;
2460   rc= memcached_set(memc, keys, key_length,
2461                     insert_data, VALUE_SIZE_BUG5,
2462                     (time_t)0, flags);
2463   test_true(rc == MEMCACHED_SUCCESS);
2464
2465   flags= 0;
2466   value= memcached_get(memc, keys, key_length,
2467                         &value_length, &flags, &rc);
2468   test_true(flags == 245);
2469   test_true(value);
2470   free(value);
2471
2472   rc= memcached_mget(memc, &keys, &key_length, 1);
2473
2474   flags= 0;
2475   value= memcached_fetch(memc, return_key, &return_key_length,
2476                          &value_length, &flags, &rc);
2477   test_true(flags == 245);
2478   test_true(value);
2479   free(value);
2480
2481
2482   return TEST_SUCCESS;
2483 }
2484
2485 static test_return_t user_supplied_bug9(memcached_st *memc)
2486 {
2487   memcached_return_t rc;
2488   const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2489   size_t key_length[3];
2490   unsigned int x;
2491   uint32_t flags;
2492   unsigned count= 0;
2493
2494   char return_key[MEMCACHED_MAX_KEY];
2495   size_t return_key_length;
2496   char *return_value;
2497   size_t return_value_length;
2498
2499
2500   key_length[0]= strlen("UDATA:edevil@sapo.pt");
2501   key_length[1]= strlen("fudge&*@#");
2502   key_length[2]= strlen("for^#@&$not");
2503
2504
2505   for (x= 0; x < 3; x++)
2506   {
2507     rc= memcached_set(memc, keys[x], key_length[x],
2508                       keys[x], key_length[x],
2509                       (time_t)50, (uint32_t)9);
2510     test_true(rc == MEMCACHED_SUCCESS);
2511   }
2512
2513   rc= memcached_mget(memc, keys, key_length, 3);
2514   test_true(rc == MEMCACHED_SUCCESS);
2515
2516   /* We need to empty the server before continueing test */
2517   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2518                       &return_value_length, &flags, &rc)) != NULL)
2519   {
2520     test_true(return_value);
2521     free(return_value);
2522     count++;
2523   }
2524   test_true(count == 3);
2525
2526   return TEST_SUCCESS;
2527 }
2528
2529 /* We are testing with aggressive timeout to get failures */
2530 static test_return_t user_supplied_bug10(memcached_st *memc)
2531 {
2532   const char *key= "foo";
2533   char *value;
2534   size_t value_length= 512;
2535   unsigned int x;
2536   size_t key_len= 3;
2537   memcached_return_t rc;
2538   unsigned int set= 1;
2539   memcached_st *mclone= memcached_clone(NULL, memc);
2540   int32_t timeout;
2541
2542   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2543   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2544   timeout= 2;
2545   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2546                          (uint64_t)timeout);
2547
2548   value = (char*)malloc(value_length * sizeof(char));
2549
2550   for (x= 0; x < value_length; x++)
2551     value[x]= (char) (x % 127);
2552
2553   for (x= 1; x <= 100000; ++x)
2554   {
2555     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2556
2557     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
2558            rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
2559
2560     if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
2561       x--;
2562   }
2563
2564   free(value);
2565   memcached_free(mclone);
2566
2567   return TEST_SUCCESS;
2568 }
2569
2570 /*
2571   We are looking failures in the async protocol
2572 */
2573 static test_return_t user_supplied_bug11(memcached_st *memc)
2574 {
2575   const char *key= "foo";
2576   char *value;
2577   size_t value_length= 512;
2578   unsigned int x;
2579   size_t key_len= 3;
2580   memcached_return_t rc;
2581   unsigned int set= 1;
2582   int32_t timeout;
2583   memcached_st *mclone= memcached_clone(NULL, memc);
2584
2585   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2586   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2587   timeout= -1;
2588   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2589                          (size_t)timeout);
2590
2591   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2592
2593   test_true(timeout == -1);
2594
2595   value = (char*)malloc(value_length * sizeof(char));
2596
2597   for (x= 0; x < value_length; x++)
2598     value[x]= (char) (x % 127);
2599
2600   for (x= 1; x <= 100000; ++x)
2601   {
2602     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2603   }
2604
2605   free(value);
2606   memcached_free(mclone);
2607
2608   return TEST_SUCCESS;
2609 }
2610
2611 /*
2612   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2613 */
2614 static test_return_t user_supplied_bug12(memcached_st *memc)
2615 {
2616   memcached_return_t rc;
2617   uint32_t flags;
2618   size_t value_length;
2619   char *value;
2620   uint64_t number_value;
2621
2622   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2623                         &value_length, &flags, &rc);
2624   test_true(value == NULL);
2625   test_true(rc == MEMCACHED_NOTFOUND);
2626
2627   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2628                           1, &number_value);
2629
2630   test_true(value == NULL);
2631   /* The binary protocol will set the key if it doesn't exist */
2632   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2633   {
2634     test_true(rc == MEMCACHED_SUCCESS);
2635   }
2636   else
2637   {
2638     test_true(rc == MEMCACHED_NOTFOUND);
2639   }
2640
2641   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2642
2643   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2644                         &value_length, &flags, &rc);
2645   test_true(value);
2646   test_true(rc == MEMCACHED_SUCCESS);
2647   free(value);
2648
2649   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2650                           1, &number_value);
2651   test_true(number_value == 2);
2652   test_true(rc == MEMCACHED_SUCCESS);
2653
2654   return TEST_SUCCESS;
2655 }
2656
2657 /*
2658   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2659   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2660  */
2661 static test_return_t user_supplied_bug13(memcached_st *memc)
2662 {
2663   char key[] = "key34567890";
2664   char *overflow;
2665   memcached_return_t rc;
2666   size_t overflowSize;
2667
2668   char commandFirst[]= "set key34567890 0 0 ";
2669   char commandLast[] = " \r\n"; /* first line of command sent to server */
2670   size_t commandLength;
2671   size_t testSize;
2672
2673   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2674
2675   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2676
2677   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2678   {
2679     overflow= malloc(testSize);
2680     test_true(overflow != NULL);
2681
2682     memset(overflow, 'x', testSize);
2683     rc= memcached_set(memc, key, strlen(key),
2684                       overflow, testSize, 0, 0);
2685     test_true(rc == MEMCACHED_SUCCESS);
2686     free(overflow);
2687   }
2688
2689   return TEST_SUCCESS;
2690 }
2691
2692
2693 /*
2694   Test values of many different sizes
2695   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2696   set key34567890 0 0 8169 \r\n
2697   is sent followed by buffer of size 8169, followed by 8169
2698  */
2699 static test_return_t user_supplied_bug14(memcached_st *memc)
2700 {
2701   size_t setter= 1;
2702   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2703   memcached_return_t rc;
2704   const char *key= "foo";
2705   char *value;
2706   size_t value_length= 18000;
2707   char *string;
2708   size_t string_length;
2709   uint32_t flags;
2710   unsigned int x;
2711   size_t current_length;
2712
2713   value = (char*)malloc(value_length);
2714   test_true(value);
2715
2716   for (x= 0; x < value_length; x++)
2717     value[x] = (char) (x % 127);
2718
2719   for (current_length= 0; current_length < value_length; current_length++)
2720   {
2721     rc= memcached_set(memc, key, strlen(key),
2722                       value, current_length,
2723                       (time_t)0, (uint32_t)0);
2724     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2725
2726     string= memcached_get(memc, key, strlen(key),
2727                           &string_length, &flags, &rc);
2728
2729     test_true(rc == MEMCACHED_SUCCESS);
2730     test_true(string_length == current_length);
2731     test_true(!memcmp(string, value, string_length));
2732
2733     free(string);
2734   }
2735
2736   free(value);
2737
2738   return TEST_SUCCESS;
2739 }
2740
2741 /*
2742   Look for zero length value problems
2743   */
2744 static test_return_t user_supplied_bug15(memcached_st *memc)
2745 {
2746   uint32_t x;
2747   memcached_return_t rc;
2748   const char *key= "mykey";
2749   char *value;
2750   size_t length;
2751   uint32_t flags;
2752
2753   for (x= 0; x < 2; x++)
2754   {
2755     rc= memcached_set(memc, key, strlen(key),
2756                       NULL, 0,
2757                       (time_t)0, (uint32_t)0);
2758
2759     test_true(rc == MEMCACHED_SUCCESS);
2760
2761     value= memcached_get(memc, key, strlen(key),
2762                          &length, &flags, &rc);
2763
2764     test_true(rc == MEMCACHED_SUCCESS);
2765     test_true(value == NULL);
2766     test_true(length == 0);
2767     test_true(flags == 0);
2768
2769     value= memcached_get(memc, key, strlen(key),
2770                          &length, &flags, &rc);
2771
2772     test_true(rc == MEMCACHED_SUCCESS);
2773     test_true(value == NULL);
2774     test_true(length == 0);
2775     test_true(flags == 0);
2776   }
2777
2778   return TEST_SUCCESS;
2779 }
2780
2781 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2782 static test_return_t user_supplied_bug16(memcached_st *memc)
2783 {
2784   memcached_return_t rc;
2785   const char *key= "mykey";
2786   char *value;
2787   size_t length;
2788   uint32_t flags;
2789
2790   rc= memcached_set(memc, key, strlen(key),
2791                     NULL, 0,
2792                     (time_t)0, UINT32_MAX);
2793
2794   test_true(rc == MEMCACHED_SUCCESS);
2795
2796   value= memcached_get(memc, key, strlen(key),
2797                        &length, &flags, &rc);
2798
2799   test_true(rc == MEMCACHED_SUCCESS);
2800   test_true(value == NULL);
2801   test_true(length == 0);
2802   test_true(flags == UINT32_MAX);
2803
2804   return TEST_SUCCESS;
2805 }
2806
2807 #if !defined(__sun) && !defined(__OpenBSD__)
2808 /* Check the validity of chinese key*/
2809 static test_return_t user_supplied_bug17(memcached_st *memc)
2810 {
2811     memcached_return_t rc;
2812     const char *key= "豆瓣";
2813     const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2814     char *value2;
2815     size_t length;
2816     uint32_t flags;
2817
2818     rc= memcached_set(memc, key, strlen(key),
2819             value, strlen(value),
2820             (time_t)0, 0);
2821
2822     test_true(rc == MEMCACHED_SUCCESS);
2823
2824     value2= memcached_get(memc, key, strlen(key),
2825             &length, &flags, &rc);
2826
2827     test_true(length==strlen(value));
2828     test_true(rc == MEMCACHED_SUCCESS);
2829     test_true(memcmp(value, value2, length)==0);
2830     free(value2);
2831
2832     return TEST_SUCCESS;
2833 }
2834 #endif
2835
2836 /*
2837   From Andrei on IRC
2838 */
2839
2840 static test_return_t user_supplied_bug19(memcached_st *not_used)
2841 {
2842   memcached_st *memc;
2843   const memcached_server_st *server;
2844   memcached_return_t res;
2845
2846   (void)not_used;
2847
2848   memc= memcached_create(NULL);
2849   memcached_server_add_with_weight(memc, "localhost", 11311, 100);
2850   memcached_server_add_with_weight(memc, "localhost", 11312, 100);
2851
2852   server= memcached_server_by_key(memc, "a", 1, &res);
2853
2854   memcached_free(memc);
2855
2856   return TEST_SUCCESS;
2857 }
2858
2859 /* CAS test from Andei */
2860 static test_return_t user_supplied_bug20(memcached_st *memc)
2861 {
2862   memcached_return_t status;
2863   memcached_result_st *result, result_obj;
2864   const char *key = "abc";
2865   size_t key_len = strlen("abc");
2866   const char *value = "foobar";
2867   size_t value_len = strlen(value);
2868
2869   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2870
2871   status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2872   test_true(status == MEMCACHED_SUCCESS);
2873
2874   status = memcached_mget(memc, &key, &key_len, 1);
2875   test_true(status == MEMCACHED_SUCCESS);
2876
2877   result= memcached_result_create(memc, &result_obj);
2878   test_true(result);
2879
2880   memcached_result_create(memc, &result_obj);
2881   result= memcached_fetch_result(memc, &result_obj, &status);
2882
2883   test_true(result);
2884   test_true(status == MEMCACHED_SUCCESS);
2885
2886   memcached_result_free(result);
2887
2888   return TEST_SUCCESS;
2889 }
2890
2891 #include "ketama_test_cases.h"
2892 static test_return_t user_supplied_bug18(memcached_st *trash)
2893 {
2894   memcached_return_t rc;
2895   uint64_t value;
2896   int x;
2897   memcached_server_st *server_pool;
2898   memcached_st *memc;
2899
2900   (void)trash;
2901
2902   memc= memcached_create(NULL);
2903   test_true(memc);
2904
2905   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2906   test_true(rc == MEMCACHED_SUCCESS);
2907
2908   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2909   test_true(value == 1);
2910
2911   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2912   test_true(rc == MEMCACHED_SUCCESS);
2913
2914   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2915   test_true(value == MEMCACHED_HASH_MD5);
2916
2917   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");
2918   memcached_server_push(memc, server_pool);
2919
2920   /* verify that the server list was parsed okay. */
2921   test_true(memcached_server_count(memc) == 8);
2922   test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2923   test_true(server_pool[0].port == 11211);
2924   test_true(server_pool[0].weight == 600);
2925   test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2926   test_true(server_pool[2].port == 11211);
2927   test_true(server_pool[2].weight == 200);
2928   test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2929   test_true(server_pool[7].port == 11211);
2930   test_true(server_pool[7].weight == 100);
2931
2932   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2933    * us test the boundary wraparound.
2934    */
2935   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
2936
2937   /* verify the standard ketama set. */
2938   for (x= 0; x < 99; x++)
2939   {
2940     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
2941
2942     memcached_server_instance_st instance=
2943       memcached_server_instance_by_position(memc, server_idx);
2944
2945     const char *hostname = memcached_server_name(instance);
2946     test_strcmp(hostname, ketama_test_cases[x].server);
2947   }
2948
2949   memcached_server_list_free(server_pool);
2950   memcached_free(memc);
2951
2952   return TEST_SUCCESS;
2953 }
2954
2955 /* Large mget() of missing keys with binary proto
2956  *
2957  * If many binary quiet commands (such as getq's in an mget) fill the output
2958  * buffer and the server chooses not to respond, memcached_flush hangs. See
2959  * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2960  */
2961
2962 /* sighandler_t function that always asserts false */
2963 static void fail(int unused __attribute__((unused)))
2964 {
2965   assert(0);
2966 }
2967
2968
2969 static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
2970 {
2971 #ifdef WIN32
2972   (void)memc;
2973   (void)key_count;
2974   return TEST_SKIPPED;
2975 #else
2976   memcached_return_t rc;
2977   unsigned int x;
2978   char **keys;
2979   size_t* key_lengths;
2980   void (*oldalarm)(int);
2981   memcached_st *memc_clone;
2982
2983   memc_clone= memcached_clone(NULL, memc);
2984   test_true(memc_clone);
2985
2986   /* only binproto uses getq for mget */
2987   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
2988
2989   /* empty the cache to ensure misses (hence non-responses) */
2990   rc= memcached_flush(memc_clone, 0);
2991   test_true(rc == MEMCACHED_SUCCESS);
2992
2993   key_lengths= calloc(key_count, sizeof(size_t));
2994   keys= calloc(key_count, sizeof(char *));
2995   test_true(keys);
2996   for (x= 0; x < key_count; x++)
2997   {
2998     char buffer[30];
2999
3000     snprintf(buffer, 30, "%u", x);
3001     keys[x]= strdup(buffer);
3002     key_lengths[x]= strlen(keys[x]);
3003   }
3004
3005   oldalarm= signal(SIGALRM, fail);
3006   alarm(5);
3007
3008   rc= memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count);
3009   test_true(rc == MEMCACHED_SUCCESS);
3010
3011   alarm(0);
3012   signal(SIGALRM, oldalarm);
3013
3014   size_t keys_returned;
3015   test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3016
3017   for (x= 0; x < key_count; x++)
3018     free(keys[x]);
3019   free(keys);
3020   free(key_lengths);
3021
3022   memcached_free(memc_clone);
3023
3024   return TEST_SUCCESS;
3025 #endif
3026 }
3027
3028 static test_return_t user_supplied_bug21(memcached_st *memc)
3029 {
3030   test_return_t test_rc;
3031   test_rc= pre_binary(memc);
3032
3033   if (test_rc != TEST_SUCCESS)
3034     return test_rc;
3035
3036   test_return_t rc;
3037
3038   /* should work as of r580 */
3039   rc= _user_supplied_bug21(memc, 10);
3040   test_true(rc == TEST_SUCCESS);
3041
3042   /* should fail as of r580 */
3043   rc= _user_supplied_bug21(memc, 1000);
3044   test_true(rc == TEST_SUCCESS);
3045
3046   return TEST_SUCCESS;
3047 }
3048
3049 static test_return_t auto_eject_hosts(memcached_st *trash)
3050 {
3051   (void) trash;
3052   memcached_server_instance_st instance;
3053
3054   memcached_return_t rc;
3055   memcached_st *memc= memcached_create(NULL);
3056   test_true(memc);
3057
3058   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3059   test_true(rc == MEMCACHED_SUCCESS);
3060
3061   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3062   test_true(value == 1);
3063
3064   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3065   test_true(rc == MEMCACHED_SUCCESS);
3066
3067   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3068   test_true(value == MEMCACHED_HASH_MD5);
3069
3070     /* server should be removed when in delay */
3071   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
3072   test_true(rc == MEMCACHED_SUCCESS);
3073
3074   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
3075   test_true(value == 1);
3076
3077   memcached_server_st *server_pool;
3078   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");
3079   memcached_server_push(memc, server_pool);
3080
3081   /* verify that the server list was parsed okay. */
3082   test_true(memcached_server_count(memc) == 8);
3083   test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
3084   test_true(server_pool[0].port == 11211);
3085   test_true(server_pool[0].weight == 600);
3086   test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
3087   test_true(server_pool[2].port == 11211);
3088   test_true(server_pool[2].weight == 200);
3089   test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
3090   test_true(server_pool[7].port == 11211);
3091   test_true(server_pool[7].weight == 100);
3092
3093   instance= memcached_server_instance_by_position(memc, 2);
3094   ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
3095   memc->next_distribution_rebuild= time(NULL) - 1;
3096
3097   /*
3098     This would not work if there were only two hosts.
3099   */
3100   for (size_t x= 0; x < 99; x++)
3101   {
3102     memcached_autoeject(memc);
3103     uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
3104     test_true(server_idx != 2);
3105   }
3106
3107   /* and re-added when it's back. */
3108   ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
3109   memc->next_distribution_rebuild= time(NULL) - 1;
3110   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
3111                          memc->distribution);
3112   for (size_t x= 0; x < 99; x++)
3113   {
3114     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
3115     // We re-use instance from above.
3116     instance=
3117       memcached_server_instance_by_position(memc, server_idx);
3118     const char *hostname = memcached_server_name(instance);
3119     test_true(strcmp(hostname, ketama_test_cases[x].server) == 0);
3120   }
3121
3122   memcached_server_list_free(server_pool);
3123   memcached_free(memc);
3124
3125   return TEST_SUCCESS;
3126 }
3127
3128 static test_return_t output_ketama_weighted_keys(memcached_st *trash)
3129 {
3130   (void) trash;
3131
3132   memcached_return_t rc;
3133   memcached_st *memc= memcached_create(NULL);
3134   test_true(memc);
3135
3136
3137   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3138   test_true(rc == MEMCACHED_SUCCESS);
3139
3140   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3141   test_true(value == 1);
3142
3143   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3144   test_true(rc == MEMCACHED_SUCCESS);
3145
3146   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3147   test_true(value == MEMCACHED_HASH_MD5);
3148
3149
3150   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
3151
3152   memcached_server_st *server_pool;
3153   server_pool = memcached_servers_parse("10.0.1.1:11211,10.0.1.2:11211,10.0.1.3:11211,10.0.1.4:11211,10.0.1.5:11211,10.0.1.6:11211,10.0.1.7:11211,10.0.1.8:11211,192.168.1.1:11211,192.168.100.1:11211");
3154   memcached_server_push(memc, server_pool);
3155
3156   // @todo this needs to be refactored to actually test something.
3157 #if 0
3158   FILE *fp;
3159   if ((fp = fopen("ketama_keys.txt", "w")))
3160   {
3161     // noop
3162   } else {
3163     printf("cannot write to file ketama_keys.txt");
3164     return TEST_FAILURE;
3165   }
3166
3167   for (int x= 0; x < 10000; x++)
3168   {
3169     char key[10];
3170     snprintf(key, sizeof(key), "%d", x);
3171
3172     uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
3173     char *hostname = memc->hosts[server_idx].hostname;
3174     in_port_t port = memc->hosts[server_idx].port;
3175     fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
3176     memcached_server_instance_st instance=
3177       memcached_server_instance_by_position(memc, host_index);
3178   }
3179   fclose(fp);
3180 #endif
3181   memcached_server_list_free(server_pool);
3182   memcached_free(memc);
3183
3184   return TEST_SUCCESS;
3185 }
3186
3187
3188 static test_return_t result_static(memcached_st *memc)
3189 {
3190   memcached_result_st result;
3191   memcached_result_st *result_ptr;
3192
3193   result_ptr= memcached_result_create(memc, &result);
3194   test_true(result.options.is_allocated == false);
3195   test_true(memcached_is_initialized(&result) == true);
3196   test_true(result_ptr);
3197   test_true(result_ptr == &result);
3198
3199   memcached_result_free(&result);
3200
3201   test_true(result.options.is_allocated == false);
3202   test_true(memcached_is_initialized(&result) == false);
3203
3204   return TEST_SUCCESS;
3205 }
3206
3207 static test_return_t result_alloc(memcached_st *memc)
3208 {
3209   memcached_result_st *result_ptr;
3210
3211   result_ptr= memcached_result_create(memc, NULL);
3212   test_true(result_ptr);
3213   test_true(result_ptr->options.is_allocated == true);
3214   test_true(memcached_is_initialized(result_ptr) == true);
3215   memcached_result_free(result_ptr);
3216
3217   return TEST_SUCCESS;
3218 }
3219
3220 static test_return_t string_static_null(memcached_st *memc)
3221 {
3222   memcached_string_st string;
3223   memcached_string_st *string_ptr;
3224
3225   string_ptr= memcached_string_create(memc, &string, 0);
3226   test_true(string.options.is_initialized == true);
3227   test_true(string_ptr);
3228
3229   /* The following two better be the same! */
3230   test_true(memcached_is_allocated(string_ptr) == false);
3231   test_true(memcached_is_allocated(&string) == false);
3232   test_true(&string == string_ptr);
3233
3234   test_true(string.options.is_initialized == true);
3235   test_true(memcached_is_initialized(&string) == true);
3236   memcached_string_free(&string);
3237   test_true(memcached_is_initialized(&string) == false);
3238
3239   return TEST_SUCCESS;
3240 }
3241
3242 static test_return_t string_alloc_null(memcached_st *memc)
3243 {
3244   memcached_string_st *string;
3245
3246   string= memcached_string_create(memc, NULL, 0);
3247   test_true(string);
3248   test_true(memcached_is_allocated(string) == true);
3249   test_true(memcached_is_initialized(string) == true);
3250   memcached_string_free(string);
3251
3252   return TEST_SUCCESS;
3253 }
3254
3255 static test_return_t string_alloc_with_size(memcached_st *memc)
3256 {
3257   memcached_string_st *string;
3258
3259   string= memcached_string_create(memc, NULL, 1024);
3260   test_true(string);
3261   test_true(memcached_is_allocated(string) == true);
3262   test_true(memcached_is_initialized(string) == true);
3263   memcached_string_free(string);
3264
3265   return TEST_SUCCESS;
3266 }
3267
3268 static test_return_t string_alloc_with_size_toobig(memcached_st *memc)
3269 {
3270   memcached_string_st *string;
3271
3272   string= memcached_string_create(memc, NULL, SIZE_MAX);
3273   test_true(string == NULL);
3274
3275   return TEST_SUCCESS;
3276 }
3277
3278 static test_return_t string_alloc_append(memcached_st *memc)
3279 {
3280   unsigned int x;
3281   char buffer[SMALL_STRING_LEN];
3282   memcached_string_st *string;
3283
3284   /* Ring the bell! */
3285   memset(buffer, 6, SMALL_STRING_LEN);
3286
3287   string= memcached_string_create(memc, NULL, 100);
3288   test_true(string);
3289   test_true(memcached_is_allocated(string) == true);
3290   test_true(memcached_is_initialized(string) == true);
3291
3292   for (x= 0; x < 1024; x++)
3293   {
3294     memcached_return_t rc;
3295     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
3296     test_true(rc == MEMCACHED_SUCCESS);
3297   }
3298   test_true(memcached_is_allocated(string) == true);
3299   memcached_string_free(string);
3300
3301   return TEST_SUCCESS;
3302 }
3303
3304 static test_return_t string_alloc_append_toobig(memcached_st *memc)
3305 {
3306   memcached_return_t rc;
3307   unsigned int x;
3308   char buffer[SMALL_STRING_LEN];
3309   memcached_string_st *string;
3310
3311   /* Ring the bell! */
3312   memset(buffer, 6, SMALL_STRING_LEN);
3313
3314   string= memcached_string_create(memc, NULL, 100);
3315   test_true(string);
3316   test_true(memcached_is_allocated(string) == true);
3317   test_true(memcached_is_initialized(string) == true);
3318
3319   for (x= 0; x < 1024; x++)
3320   {
3321     rc= memcached_string_append(string, buffer, SMALL_STRING_LEN);
3322     test_true(rc == MEMCACHED_SUCCESS);
3323   }
3324   rc= memcached_string_append(string, buffer, SIZE_MAX);
3325   test_true(rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE);
3326   test_true(memcached_is_allocated(string) == true);
3327   memcached_string_free(string);
3328
3329   return TEST_SUCCESS;
3330 }
3331
3332 static test_return_t cleanup_pairs(memcached_st *memc __attribute__((unused)))
3333 {
3334   pairs_free(global_pairs);
3335
3336   return TEST_SUCCESS;
3337 }
3338
3339 static test_return_t generate_pairs(memcached_st *memc __attribute__((unused)))
3340 {
3341   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
3342   global_count= GLOBAL_COUNT;
3343
3344   for (size_t x= 0; x < global_count; x++)
3345   {
3346     global_keys[x]= global_pairs[x].key;
3347     global_keys_length[x]=  global_pairs[x].key_length;
3348   }
3349
3350   return TEST_SUCCESS;
3351 }
3352
3353 static test_return_t generate_large_pairs(memcached_st *memc __attribute__((unused)))
3354 {
3355   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
3356   global_count= GLOBAL2_COUNT;
3357
3358   for (size_t x= 0; x < global_count; x++)
3359   {
3360     global_keys[x]= global_pairs[x].key;
3361     global_keys_length[x]=  global_pairs[x].key_length;
3362   }
3363
3364   return TEST_SUCCESS;
3365 }
3366
3367 static test_return_t generate_data(memcached_st *memc)
3368 {
3369   unsigned int check_execute= execute_set(memc, global_pairs, global_count);
3370
3371   test_true(check_execute == global_count);
3372
3373   return TEST_SUCCESS;
3374 }
3375
3376 static test_return_t generate_data_with_stats(memcached_st *memc)
3377 {
3378   memcached_stat_st *stat_p;
3379   memcached_return_t rc;
3380   uint32_t host_index= 0;
3381   unsigned int check_execute= execute_set(memc, global_pairs, global_count);
3382
3383   test_true(check_execute == global_count);
3384
3385   //TODO: hosts used size stats
3386   stat_p= memcached_stat(memc, NULL, &rc);
3387   test_true(stat_p);
3388
3389   for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
3390   {
3391     /* This test was changes so that "make test" would work properlly */
3392 #ifdef DEBUG
3393     memcached_server_instance_st instance=
3394       memcached_server_instance_by_position(memc, host_index);
3395
3396     printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
3397 #endif
3398     test_true((unsigned long long)(stat_p + host_index)->bytes);
3399   }
3400
3401   memcached_stat_free(NULL, stat_p);
3402
3403   return TEST_SUCCESS;
3404 }
3405 static test_return_t generate_buffer_data(memcached_st *memc)
3406 {
3407   size_t latch= 0;
3408
3409   latch= 1;
3410   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3411   generate_data(memc);
3412
3413   return TEST_SUCCESS;
3414 }
3415
3416 static test_return_t get_read_count(memcached_st *memc)
3417 {
3418   memcached_return_t rc;
3419   memcached_st *memc_clone;
3420
3421   memc_clone= memcached_clone(NULL, memc);
3422   test_true(memc_clone);
3423
3424   memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
3425
3426   {
3427     char *return_value;
3428     size_t return_value_length;
3429     uint32_t flags;
3430     uint32_t count;
3431
3432     for (size_t x= count= 0; x < global_count; x++)
3433     {
3434       return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
3435                                   &return_value_length, &flags, &rc);
3436       if (rc == MEMCACHED_SUCCESS)
3437       {
3438         count++;
3439         if (return_value)
3440           free(return_value);
3441       }
3442     }
3443   }
3444
3445   memcached_free(memc_clone);
3446
3447   return TEST_SUCCESS;
3448 }
3449
3450 static test_return_t get_read(memcached_st *memc)
3451 {
3452   memcached_return_t rc;
3453
3454   {
3455     char *return_value;
3456     size_t return_value_length;
3457     uint32_t flags;
3458
3459     for (size_t x= 0; x < global_count; x++)
3460     {
3461       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
3462                                   &return_value_length, &flags, &rc);
3463       /*
3464       test_true(return_value);
3465       test_true(rc == MEMCACHED_SUCCESS);
3466     */
3467       if (rc == MEMCACHED_SUCCESS && return_value)
3468         free(return_value);
3469     }
3470   }
3471
3472   return TEST_SUCCESS;
3473 }
3474
3475 static test_return_t mget_read(memcached_st *memc)
3476 {
3477   memcached_return_t rc;
3478
3479   if (! libmemcached_util_version_check(memc, 1, 4, 4))
3480     return TEST_SKIPPED;
3481
3482   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3483
3484   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3485
3486   // Go fetch the keys and test to see if all of them were returned
3487   {
3488     size_t keys_returned;
3489     test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3490     char buffer[30];
3491     snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
3492     test_true_got(global_count == keys_returned, buffer);
3493   }
3494
3495
3496   return TEST_SUCCESS;
3497 }
3498
3499 static test_return_t mget_read_result(memcached_st *memc)
3500 {
3501   memcached_return_t rc;
3502
3503   if (! libmemcached_util_version_check(memc, 1, 4, 4))
3504     return TEST_SKIPPED;
3505
3506   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3507
3508   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3509
3510   /* Turn this into a help function */
3511   {
3512     memcached_result_st results_obj;
3513     memcached_result_st *results;
3514
3515     results= memcached_result_create(memc, &results_obj);
3516
3517     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
3518     {
3519       test_true(results);
3520       test_true(rc == MEMCACHED_SUCCESS);
3521     }
3522
3523     memcached_result_free(&results_obj);
3524   }
3525
3526   return TEST_SUCCESS;
3527 }
3528
3529 static test_return_t mget_read_function(memcached_st *memc)
3530 {
3531   memcached_return_t rc;
3532   size_t counter;
3533   memcached_execute_fn callbacks[1];
3534
3535   if (! libmemcached_util_version_check(memc, 1, 4, 4))
3536     return TEST_SKIPPED;
3537
3538   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3539
3540   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3541
3542   callbacks[0]= &callback_counter;
3543   counter= 0;
3544   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
3545
3546   return TEST_SUCCESS;
3547 }
3548
3549 static test_return_t delete_generate(memcached_st *memc)
3550 {
3551   for (size_t x= 0; x < global_count; x++)
3552   {
3553     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3554   }
3555
3556   return TEST_SUCCESS;
3557 }
3558
3559 static test_return_t delete_buffer_generate(memcached_st *memc)
3560 {
3561   uint64_t latch= 0;
3562
3563   latch= 1;
3564   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3565
3566   for (size_t x= 0; x < global_count; x++)
3567   {
3568     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3569   }
3570
3571   return TEST_SUCCESS;
3572 }
3573
3574 static test_return_t add_host_test1(memcached_st *memc)
3575 {
3576   memcached_return_t rc;
3577   char servername[]= "0.example.com";
3578   memcached_server_st *servers;
3579
3580   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
3581   test_true(servers);
3582   test_true(1 == memcached_server_list_count(servers));
3583
3584   for (size_t x= 2; x < 20; x++)
3585   {
3586     char buffer[SMALL_STRING_LEN];
3587
3588     snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
3589     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
3590                                      &rc);
3591     test_true(rc == MEMCACHED_SUCCESS);
3592     test_true(x == memcached_server_list_count(servers));
3593   }
3594
3595   rc= memcached_server_push(memc, servers);
3596   test_true(rc == MEMCACHED_SUCCESS);
3597   rc= memcached_server_push(memc, servers);
3598   test_true(rc == MEMCACHED_SUCCESS);
3599
3600   memcached_server_list_free(servers);
3601
3602   return TEST_SUCCESS;
3603 }
3604
3605 static test_return_t pre_nonblock(memcached_st *memc)
3606 {
3607   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3608
3609   return TEST_SUCCESS;
3610 }
3611
3612 static test_return_t pre_cork(memcached_st *memc)
3613 {
3614   memcached_return_t rc;
3615   bool set= true;
3616
3617   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
3618
3619 #ifdef __APPLE__
3620   return TEST_SKIPPED;
3621 #endif
3622
3623   if (rc == MEMCACHED_SUCCESS)
3624     return TEST_SUCCESS;
3625
3626   return TEST_SKIPPED;
3627 }
3628
3629 static test_return_t pre_cork_and_nonblock(memcached_st *memc)
3630 {
3631   test_return_t rc;
3632
3633   rc= pre_cork(memc);
3634
3635 #ifdef __APPLE__
3636   return TEST_SKIPPED;
3637 #endif
3638
3639   if (rc != TEST_SUCCESS)
3640     return rc;
3641
3642   return pre_nonblock(memc);
3643 }
3644
3645 static test_return_t pre_nonblock_binary(memcached_st *memc)
3646 {
3647   memcached_return_t rc= MEMCACHED_FAILURE;
3648   memcached_st *memc_clone;
3649
3650   memc_clone= memcached_clone(NULL, memc);
3651   test_true(memc_clone);
3652   // The memcached_version needs to be done on a clone, because the server
3653   // will not toggle protocol on an connection.
3654   memcached_version(memc_clone);
3655
3656   if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
3657   {
3658     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3659     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3660     test_true(rc == MEMCACHED_SUCCESS);
3661     test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3662   }
3663   else
3664   {
3665     return TEST_SKIPPED;
3666   }
3667
3668   memcached_free(memc_clone);
3669
3670   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3671 }
3672
3673 static test_return_t pre_murmur(memcached_st *memc)
3674 {
3675   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3676
3677   return TEST_SUCCESS;
3678 }
3679
3680 static test_return_t pre_jenkins(memcached_st *memc)
3681 {
3682   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
3683
3684   return TEST_SUCCESS;
3685 }
3686
3687
3688 static test_return_t pre_md5(memcached_st *memc)
3689 {
3690   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
3691
3692   return TEST_SUCCESS;
3693 }
3694
3695 static test_return_t pre_crc(memcached_st *memc)
3696 {
3697   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
3698
3699   return TEST_SUCCESS;
3700 }
3701
3702 static test_return_t pre_hsieh(memcached_st *memc)
3703 {
3704 #ifdef HAVE_HSIEH_HASH
3705   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
3706   return TEST_SUCCESS;
3707 #else
3708   (void) memc;
3709   return TEST_SKIPPED;
3710 #endif
3711 }
3712
3713 static test_return_t pre_hash_fnv1_64(memcached_st *memc)
3714 {
3715   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3716
3717   return TEST_SUCCESS;
3718 }
3719
3720 static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
3721 {
3722   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
3723
3724   return TEST_SUCCESS;
3725 }
3726
3727 static test_return_t pre_hash_fnv1_32(memcached_st *memc)
3728 {
3729   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
3730
3731   return TEST_SUCCESS;
3732 }
3733
3734 static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
3735 {
3736   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
3737
3738   return TEST_SUCCESS;
3739 }
3740
3741 static test_return_t pre_behavior_ketama(memcached_st *memc)
3742 {
3743   memcached_return_t rc;
3744   uint64_t value;
3745
3746   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
3747   test_true(rc == MEMCACHED_SUCCESS);
3748
3749   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
3750   test_true(value == 1);
3751
3752   return TEST_SUCCESS;
3753 }
3754
3755 static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
3756 {
3757   memcached_return_t rc;
3758   uint64_t value;
3759
3760   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3761   test_true(rc == MEMCACHED_SUCCESS);
3762
3763   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3764   test_true(value == 1);
3765
3766   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3767   test_true(rc == MEMCACHED_SUCCESS);
3768
3769   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3770   test_true(value == MEMCACHED_HASH_MD5);
3771
3772   return TEST_SUCCESS;
3773 }
3774
3775 /**
3776   @note This should be testing to see if the server really supports the binary protocol.
3777 */
3778 static test_return_t pre_binary(memcached_st *memc)
3779 {
3780   memcached_return_t rc= MEMCACHED_FAILURE;
3781
3782   if (libmemcached_util_version_check(memc, 1, 4, 4))
3783   {
3784     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3785     test_true(rc == MEMCACHED_SUCCESS);
3786     test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3787   }
3788
3789   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3790 }
3791
3792 static test_return_t pre_sasl(memcached_st *memc)
3793 {
3794   memcached_return_t rc= MEMCACHED_FAILURE;
3795
3796 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3797   const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3798   const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3799   const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3800
3801   if (server != NULL && user != NULL && pass != NULL)
3802   {
3803     memcached_server_st *servers= memcached_servers_parse(server);
3804     test_true(servers != NULL);
3805     memcached_servers_reset(memc);
3806     test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
3807     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3808     rc= memcached_set_sasl_auth_data(memc, user, pass);
3809     test_true(rc == MEMCACHED_SUCCESS);
3810   }
3811 #else
3812   (void)memc;
3813 #endif
3814
3815   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3816 }
3817
3818 static test_return_t pre_replication(memcached_st *memc)
3819 {
3820   test_return_t test_rc;
3821   test_rc= pre_binary(memc);
3822
3823   if (test_rc != TEST_SUCCESS)
3824     return test_rc;
3825
3826   /*
3827    * Make sure that we store the item on all servers
3828    * (master + replicas == number of servers)
3829    */
3830   memcached_return_t rc;
3831   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
3832                              memcached_server_count(memc) - 1);
3833   test_true(rc == MEMCACHED_SUCCESS);
3834   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
3835
3836   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3837 }
3838
3839
3840 static test_return_t pre_replication_noblock(memcached_st *memc)
3841 {
3842   test_return_t rc;
3843
3844   rc= pre_replication(memc);
3845   if (rc != TEST_SUCCESS)
3846     return rc;
3847
3848   rc= pre_nonblock(memc);
3849
3850   return rc;
3851 }
3852
3853
3854 static void my_free(const memcached_st *ptr __attribute__((unused)), void *mem, void *context)
3855 {
3856   (void) context;
3857 #ifdef HARD_MALLOC_TESTS
3858   void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
3859   free(real_ptr);
3860 #else
3861   free(mem);
3862 #endif
3863 }
3864
3865
3866 static void *my_malloc(const memcached_st *ptr __attribute__((unused)), const size_t size, void *context)
3867 {
3868   (void)context;
3869 #ifdef HARD_MALLOC_TESTS
3870   void *ret= malloc(size + 8);
3871   if (ret != NULL)
3872   {
3873     ret= (void*)((caddr_t)ret + 8);
3874   }
3875 #else
3876   void *ret= malloc(size);
3877 #endif
3878
3879   if (ret != NULL)
3880   {
3881     memset(ret, 0xff, size);
3882   }
3883
3884   return ret;
3885 }
3886
3887
3888 static void *my_realloc(const memcached_st *ptr __attribute__((unused)), void *mem, const size_t size, void *context)
3889 {
3890   (void)context;
3891 #ifdef HARD_MALLOC_TESTS
3892   void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
3893   void *nmem= realloc(real_ptr, size + 8);
3894
3895   void *ret= NULL;
3896   if (nmem != NULL)
3897   {
3898     ret= (void*)((caddr_t)nmem + 8);
3899   }
3900
3901   return ret;
3902 #else
3903   return realloc(mem, size);
3904 #endif
3905 }
3906
3907
3908 static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size, void *context)
3909 {
3910   (void)context;
3911 #ifdef HARD_MALLOC_TESTS
3912   void *mem= my_malloc(ptr, nelem * size);
3913   if (mem)
3914   {
3915     memset(mem, 0, nelem * size);
3916   }
3917
3918   return mem;
3919 #else
3920   return calloc(nelem, size);
3921 #endif
3922 }
3923
3924
3925 static test_return_t set_prefix(memcached_st *memc)
3926 {
3927   memcached_return_t rc;
3928   const char *key= "mine";
3929   char *value;
3930
3931   /* Make sure be default none exists */
3932   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3933   test_true(rc == MEMCACHED_FAILURE);
3934
3935   /* Test a clean set */
3936   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3937   test_true(rc == MEMCACHED_SUCCESS);
3938
3939   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3940   test_true(memcmp(value, key, 4) == 0);
3941   test_true(rc == MEMCACHED_SUCCESS);
3942
3943   /* Test that we can turn it off */
3944   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3945   test_true(rc == MEMCACHED_SUCCESS);
3946
3947   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3948   test_true(rc == MEMCACHED_FAILURE);
3949
3950   /* Now setup for main test */
3951   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3952   test_true(rc == MEMCACHED_SUCCESS);
3953
3954   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3955   test_true(rc == MEMCACHED_SUCCESS);
3956   test_true(memcmp(value, key, 4) == 0);
3957
3958   /* Set to Zero, and then Set to something too large */
3959   {
3960     char long_key[255];
3961     memset(long_key, 0, 255);
3962
3963     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3964     test_true(rc == MEMCACHED_SUCCESS);
3965
3966     value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3967     test_true(rc == MEMCACHED_FAILURE);
3968     test_true(value == NULL);
3969
3970     /* Test a long key for failure */
3971     /* TODO, extend test to determine based on setting, what result should be */
3972     strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
3973     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3974     //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3975     test_true(rc == MEMCACHED_SUCCESS);
3976
3977     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3978     strcpy(long_key, "This is more then the allotted number of characters");
3979     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3980     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3981
3982     /* Test for a bad prefix, but with a short key */
3983     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3984     test_true(rc == MEMCACHED_SUCCESS);
3985
3986     strcpy(long_key, "dog cat");
3987     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3988     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3989   }
3990
3991   return TEST_SUCCESS;
3992 }
3993
3994
3995 #ifdef MEMCACHED_ENABLE_DEPRECATED
3996 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
3997 {
3998   void *test_ptr= NULL;
3999   void *cb_ptr= NULL;
4000   {
4001     memcached_malloc_fn malloc_cb=
4002       (memcached_malloc_fn)my_malloc;
4003     cb_ptr= *(void **)&malloc_cb;
4004     memcached_return_t rc;
4005
4006     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
4007     test_true(rc == MEMCACHED_SUCCESS);
4008     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
4009     test_true(rc == MEMCACHED_SUCCESS);
4010     test_true(test_ptr == cb_ptr);
4011   }
4012
4013   {
4014     memcached_realloc_fn realloc_cb=
4015       (memcached_realloc_fn)my_realloc;
4016     cb_ptr= *(void **)&realloc_cb;
4017     memcached_return_t rc;
4018
4019     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
4020     test_true(rc == MEMCACHED_SUCCESS);
4021     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
4022     test_true(rc == MEMCACHED_SUCCESS);
4023     test_true(test_ptr == cb_ptr);
4024   }
4025
4026   {
4027     memcached_free_fn free_cb=
4028       (memcached_free_fn)my_free;
4029     cb_ptr= *(void **)&free_cb;
4030     memcached_return_t rc;
4031
4032     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
4033     test_true(rc == MEMCACHED_SUCCESS);
4034     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
4035     test_true(rc == MEMCACHED_SUCCESS);
4036     test_true(test_ptr == cb_ptr);
4037   }
4038
4039   return TEST_SUCCESS;
4040 }
4041 #endif
4042
4043
4044 static test_return_t set_memory_alloc(memcached_st *memc)
4045 {
4046   memcached_return_t rc;
4047   rc= memcached_set_memory_allocators(memc, NULL, my_free,
4048                                       my_realloc, my_calloc, NULL);
4049   test_true(rc == MEMCACHED_FAILURE);
4050
4051   rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
4052                                       my_realloc, my_calloc, NULL);
4053
4054   memcached_malloc_fn mem_malloc;
4055   memcached_free_fn mem_free;
4056   memcached_realloc_fn mem_realloc;
4057   memcached_calloc_fn mem_calloc;
4058   memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
4059                                   &mem_realloc, &mem_calloc);
4060
4061   test_true(mem_malloc == my_malloc);
4062   test_true(mem_realloc == my_realloc);
4063   test_true(mem_calloc == my_calloc);
4064   test_true(mem_free == my_free);
4065
4066   return TEST_SUCCESS;
4067 }
4068
4069 static test_return_t enable_consistent_crc(memcached_st *memc)
4070 {
4071   test_return_t rc;
4072   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
4073   memcached_hash_t hash;
4074   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
4075   if ((rc= pre_crc(memc)) != TEST_SUCCESS)
4076     return rc;
4077
4078   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
4079   test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
4080
4081   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
4082
4083   if (hash != MEMCACHED_HASH_CRC)
4084     return TEST_SKIPPED;
4085
4086   return TEST_SUCCESS;
4087 }
4088
4089 static test_return_t enable_consistent_hsieh(memcached_st *memc)
4090 {
4091   test_return_t rc;
4092   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
4093   memcached_hash_t hash;
4094   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
4095   if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
4096     return rc;
4097
4098   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
4099   test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
4100
4101   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
4102
4103   if (hash != MEMCACHED_HASH_HSIEH)
4104     return TEST_SKIPPED;
4105
4106
4107   return TEST_SUCCESS;
4108 }
4109
4110 static test_return_t enable_cas(memcached_st *memc)
4111 {
4112   unsigned int set= 1;
4113
4114   if (libmemcached_util_version_check(memc, 1, 2, 4))
4115   {
4116     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
4117
4118     return TEST_SUCCESS;
4119   }
4120
4121   return TEST_SKIPPED;
4122 }
4123
4124 static test_return_t check_for_1_2_3(memcached_st *memc)
4125 {
4126   memcached_version(memc);
4127
4128   memcached_server_instance_st instance=
4129     memcached_server_instance_by_position(memc, 0);
4130
4131   if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
4132       || instance->minor_version > 2)
4133   {
4134     return TEST_SUCCESS;
4135   }
4136
4137   return TEST_SKIPPED;
4138 }
4139
4140 static test_return_t pre_unix_socket(memcached_st *memc)
4141 {
4142   memcached_return_t rc;
4143   struct stat buf;
4144
4145   memcached_servers_reset(memc);
4146
4147   if (stat("/tmp/memcached.socket", &buf))
4148     return TEST_SKIPPED;
4149
4150   rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
4151
4152   return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
4153 }
4154
4155 static test_return_t pre_nodelay(memcached_st *memc)
4156 {
4157   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
4158   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
4159
4160   return TEST_SUCCESS;
4161 }
4162
4163 static test_return_t pre_settimer(memcached_st *memc)
4164 {
4165   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
4166   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
4167
4168   return TEST_SUCCESS;
4169 }
4170
4171 static test_return_t poll_timeout(memcached_st *memc)
4172 {
4173   size_t timeout;
4174
4175   timeout= 100;
4176
4177   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
4178
4179   timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
4180
4181   test_true(timeout == 100);
4182
4183   return TEST_SUCCESS;
4184 }
4185
4186 static test_return_t noreply_test(memcached_st *memc)
4187 {
4188   memcached_return_t ret;
4189   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
4190   test_true(ret == MEMCACHED_SUCCESS);
4191   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4192   test_true(ret == MEMCACHED_SUCCESS);
4193   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
4194   test_true(ret == MEMCACHED_SUCCESS);
4195   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
4196   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
4197   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
4198
4199   for (int count=0; count < 5; ++count)
4200   {
4201     for (size_t x= 0; x < 100; ++x)
4202     {
4203       char key[10];
4204       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4205       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4206
4207       size_t len= (size_t)check_length;
4208
4209       switch (count)
4210       {
4211       case 0:
4212         ret= memcached_add(memc, key, len, key, len, 0, 0);
4213         break;
4214       case 1:
4215         ret= memcached_replace(memc, key, len, key, len, 0, 0);
4216         break;
4217       case 2:
4218         ret= memcached_set(memc, key, len, key, len, 0, 0);
4219         break;
4220       case 3:
4221         ret= memcached_append(memc, key, len, key, len, 0, 0);
4222         break;
4223       case 4:
4224         ret= memcached_prepend(memc, key, len, key, len, 0, 0);
4225         break;
4226       default:
4227         test_true(count);
4228         break;
4229       }
4230       test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
4231     }
4232
4233     /*
4234     ** NOTE: Don't ever do this in your code! this is not a supported use of the
4235     ** API and is _ONLY_ done this way to verify that the library works the
4236     ** way it is supposed to do!!!!
4237     */
4238     int no_msg=0;
4239     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
4240     {
4241       memcached_server_instance_st instance=
4242         memcached_server_instance_by_position(memc, x);
4243       no_msg+=(int)(instance->cursor_active);
4244     }
4245
4246     test_true(no_msg == 0);
4247     test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4248
4249     /*
4250      ** Now validate that all items was set properly!
4251      */
4252     for (size_t x= 0; x < 100; ++x)
4253     {
4254       char key[10];
4255
4256       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4257
4258       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4259
4260       size_t len= (size_t)check_length;
4261       size_t length;
4262       uint32_t flags;
4263       char* value=memcached_get(memc, key, strlen(key),
4264                                 &length, &flags, &ret);
4265       test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4266       switch (count)
4267       {
4268       case 0: /* FALLTHROUGH */
4269       case 1: /* FALLTHROUGH */
4270       case 2:
4271         test_true(strncmp(value, key, len) == 0);
4272         test_true(len == length);
4273         break;
4274       case 3:
4275         test_true(length == len * 2);
4276         break;
4277       case 4:
4278         test_true(length == len * 3);
4279         break;
4280       default:
4281         test_true(count);
4282         break;
4283       }
4284       free(value);
4285     }
4286   }
4287
4288   /* Try setting an illegal cas value (should not return an error to
4289    * the caller (because we don't expect a return message from the server)
4290    */
4291   const char* keys[]= {"0"};
4292   size_t lengths[]= {1};
4293   size_t length;
4294   uint32_t flags;
4295   memcached_result_st results_obj;
4296   memcached_result_st *results;
4297   ret= memcached_mget(memc, keys, lengths, 1);
4298   test_true(ret == MEMCACHED_SUCCESS);
4299
4300   results= memcached_result_create(memc, &results_obj);
4301   test_true(results);
4302   results= memcached_fetch_result(memc, &results_obj, &ret);
4303   test_true(results);
4304   test_true(ret == MEMCACHED_SUCCESS);
4305   uint64_t cas= memcached_result_cas(results);
4306   memcached_result_free(&results_obj);
4307
4308   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4309   test_true(ret == MEMCACHED_SUCCESS);
4310
4311   /*
4312    * The item will have a new cas value, so try to set it again with the old
4313    * value. This should fail!
4314    */
4315   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4316   test_true(ret == MEMCACHED_SUCCESS);
4317   test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4318   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
4319   test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4320   free(value);
4321
4322   return TEST_SUCCESS;
4323 }
4324
4325 static test_return_t analyzer_test(memcached_st *memc)
4326 {
4327   memcached_return_t rc;
4328   memcached_stat_st *memc_stat;
4329   memcached_analysis_st *report;
4330
4331   memc_stat= memcached_stat(memc, NULL, &rc);
4332   test_true(rc == MEMCACHED_SUCCESS);
4333   test_true(memc_stat);
4334
4335   report= memcached_analyze(memc, memc_stat, &rc);
4336   test_true(rc == MEMCACHED_SUCCESS);
4337   test_true(report);
4338
4339   free(report);
4340   memcached_stat_free(NULL, memc_stat);
4341
4342   return TEST_SUCCESS;
4343 }
4344
4345 /* Count the objects */
4346 static memcached_return_t callback_dump_counter(const memcached_st *ptr __attribute__((unused)),
4347                                                 const char *key __attribute__((unused)),
4348                                                 size_t key_length __attribute__((unused)),
4349                                                 void *context)
4350 {
4351   size_t *counter= (size_t *)context;
4352
4353   *counter= *counter + 1;
4354
4355   return MEMCACHED_SUCCESS;
4356 }
4357
4358 static test_return_t dump_test(memcached_st *memc)
4359 {
4360   memcached_return_t rc;
4361   size_t counter= 0;
4362   memcached_dump_fn callbacks[1];
4363   test_return_t main_rc;
4364
4365   callbacks[0]= &callback_dump_counter;
4366
4367   /* No support for Binary protocol yet */
4368   if (memc->flags.binary_protocol)
4369     return TEST_SUCCESS;
4370
4371   main_rc= set_test3(memc);
4372
4373   test_true (main_rc == TEST_SUCCESS);
4374
4375   rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
4376   test_true(rc == MEMCACHED_SUCCESS);
4377
4378   /* We may have more then 32 if our previous flush has not completed */
4379   test_true(counter >= 32);
4380
4381   return TEST_SUCCESS;
4382 }
4383
4384 #ifdef HAVE_LIBMEMCACHEDUTIL
4385 static void* connection_release(void *arg)
4386 {
4387   struct {
4388     memcached_pool_st* pool;
4389     memcached_st* mmc;
4390   } *resource= arg;
4391
4392   usleep(250);
4393   assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
4394   return arg;
4395 }
4396
4397 #define POOL_SIZE 10
4398 static test_return_t connection_pool_test(memcached_st *memc)
4399 {
4400   memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
4401   test_true(pool != NULL);
4402   memcached_st *mmc[POOL_SIZE];
4403   memcached_return_t rc;
4404
4405   for (size_t x= 0; x < POOL_SIZE; ++x)
4406   {
4407     mmc[x]= memcached_pool_pop(pool, false, &rc);
4408     test_true(mmc[x] != NULL);
4409     test_true(rc == MEMCACHED_SUCCESS);
4410   }
4411
4412   test_true(memcached_pool_pop(pool, false, &rc) == NULL);
4413   test_true(rc == MEMCACHED_SUCCESS);
4414
4415   pthread_t tid;
4416   struct {
4417     memcached_pool_st* pool;
4418     memcached_st* mmc;
4419   } item= { .pool = pool, .mmc = mmc[9] };
4420   pthread_create(&tid, NULL, connection_release, &item);
4421   mmc[9]= memcached_pool_pop(pool, true, &rc);
4422   test_true(rc == MEMCACHED_SUCCESS);
4423   pthread_join(tid, NULL);
4424   test_true(mmc[9] == item.mmc);
4425   const char *key= "key";
4426   size_t keylen= strlen(key);
4427
4428   // verify that I can do ops with all connections
4429   rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
4430   test_true(rc == MEMCACHED_SUCCESS);
4431
4432   for (size_t x= 0; x < POOL_SIZE; ++x)
4433   {
4434     uint64_t number_value;
4435     rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
4436     test_true(rc == MEMCACHED_SUCCESS);
4437     test_true(number_value == (x+1));
4438   }
4439
4440   // Release them..
4441   for (size_t x= 0; x < POOL_SIZE; ++x)
4442   {
4443     test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
4444   }
4445
4446
4447   /* verify that I can set behaviors on the pool when I don't have all
4448    * of the connections in the pool. It should however be enabled
4449    * when I push the item into the pool
4450    */
4451   mmc[0]= memcached_pool_pop(pool, false, &rc);
4452   test_true(mmc[0] != NULL);
4453
4454   rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
4455   test_true(rc == MEMCACHED_SUCCESS);
4456
4457   mmc[1]= memcached_pool_pop(pool, false, &rc);
4458   test_true(mmc[1] != NULL);
4459
4460   test_true(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4461   test_true(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
4462   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4463
4464   mmc[0]= memcached_pool_pop(pool, false, &rc);
4465   test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4466   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4467
4468   test_true(memcached_pool_destroy(pool) == memc);
4469
4470   return TEST_SUCCESS;
4471 }
4472
4473 static test_return_t util_version_test(memcached_st *memc)
4474 {
4475   bool if_successful;
4476
4477   if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
4478   test_true(if_successful == true);
4479
4480   if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
4481
4482   // We expect failure
4483   if (if_successful)
4484   {
4485     fprintf(stderr, "\n----------------------------------------------------------------------\n");
4486     fprintf(stderr, "\nDumping Server Information\n\n");
4487     memcached_server_fn callbacks[1];
4488
4489     callbacks[0]= dump_server_information;
4490     memcached_server_cursor(memc, callbacks, (void *)stderr,  1);
4491     fprintf(stderr, "\n----------------------------------------------------------------------\n");
4492   }
4493   test_true(if_successful == false);
4494
4495   memcached_server_instance_st instance=
4496     memcached_server_instance_by_position(memc, 0);
4497
4498   memcached_version(memc);
4499
4500   // We only use one binary when we test, so this should be just fine.
4501   if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
4502   test_true(if_successful == true);
4503
4504   if (instance->micro_version > 0)
4505     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
4506   else if (instance->minor_version > 0)
4507     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
4508   else if (instance->major_version > 0)
4509     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
4510
4511   test_true(if_successful == true);
4512
4513   if (instance->micro_version > 0)
4514     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
4515   else if (instance->minor_version > 0)
4516     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
4517   else if (instance->major_version > 0)
4518     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
4519
4520   test_true(if_successful == false);
4521
4522   return TEST_SUCCESS;
4523 }
4524
4525 static test_return_t ping_test(memcached_st *memc)
4526 {
4527   memcached_return_t rc;
4528   memcached_server_instance_st instance=
4529     memcached_server_instance_by_position(memc, 0);
4530
4531   // Test both the version that returns a code, and the one that does not.
4532   test_true(libmemcached_util_ping(memcached_server_name(instance),
4533                                    memcached_server_port(instance), NULL));
4534
4535   test_true(libmemcached_util_ping(memcached_server_name(instance),
4536                                    memcached_server_port(instance), &rc));
4537
4538   test_true(rc == MEMCACHED_SUCCESS);
4539
4540   return TEST_SUCCESS;
4541 }
4542 #endif
4543
4544 static test_return_t replication_set_test(memcached_st *memc)
4545 {
4546   memcached_return_t rc;
4547   memcached_st *memc_clone= memcached_clone(NULL, memc);
4548   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
4549
4550   rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
4551   test_true(rc == MEMCACHED_SUCCESS);
4552
4553   /*
4554   ** We are using the quiet commands to store the replicas, so we need
4555   ** to ensure that all of them are processed before we can continue.
4556   ** In the test we go directly from storing the object to trying to
4557   ** receive the object from all of the different servers, so we
4558   ** could end up in a race condition (the memcached server hasn't yet
4559   ** processed the quiet command from the replication set when it process
4560   ** the request from the other client (created by the clone)). As a
4561   ** workaround for that we call memcached_quit to send the quit command
4562   ** to the server and wait for the response ;-) If you use the test code
4563   ** as an example for your own code, please note that you shouldn't need
4564   ** to do this ;-)
4565   */
4566   memcached_quit(memc);
4567
4568   /*
4569   ** "bubba" should now be stored on all of our servers. We don't have an
4570   ** easy to use API to address each individual server, so I'll just iterate
4571   ** through a bunch of "master keys" and I should most likely hit all of the
4572   ** servers...
4573   */
4574   for (int x= 'a'; x <= 'z'; ++x)
4575   {
4576     char key[2]= { [0]= (char)x };
4577     size_t len;
4578     uint32_t flags;
4579     char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
4580                                     &len, &flags, &rc);
4581     test_true(rc == MEMCACHED_SUCCESS);
4582     test_true(val != NULL);
4583     free(val);
4584   }
4585
4586   memcached_free(memc_clone);
4587
4588   return TEST_SUCCESS;
4589 }
4590
4591 static test_return_t replication_get_test(memcached_st *memc)
4592 {
4593   memcached_return_t rc;
4594
4595   /*
4596    * Don't do the following in your code. I am abusing the internal details
4597    * within the library, and this is not a supported interface.
4598    * This is to verify correct behavior in the library
4599    */
4600   for (uint32_t host= 0; host < memcached_server_count(memc); ++host)
4601   {
4602     memcached_st *memc_clone= memcached_clone(NULL, memc);
4603     memcached_server_instance_st instance=
4604       memcached_server_instance_by_position(memc_clone, host);
4605
4606     ((memcached_server_write_instance_st)instance)->port= 0;
4607
4608     for (int x= 'a'; x <= 'z'; ++x)
4609     {
4610       char key[2]= { [0]= (char)x };
4611       size_t len;
4612       uint32_t flags;
4613       char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
4614                                       &len, &flags, &rc);
4615       test_true(rc == MEMCACHED_SUCCESS);
4616       test_true(val != NULL);
4617       free(val);
4618     }
4619
4620     memcached_free(memc_clone);
4621   }
4622
4623   return TEST_SUCCESS;
4624 }
4625
4626 static test_return_t replication_mget_test(memcached_st *memc)
4627 {
4628   memcached_return_t rc;
4629   memcached_st *memc_clone= memcached_clone(NULL, memc);
4630   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
4631
4632   const char *keys[]= { "bubba", "key1", "key2", "key3" };
4633   size_t len[]= { 5, 4, 4, 4 };
4634
4635   for (size_t x= 0; x< 4; ++x)
4636   {
4637     rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
4638     test_true(rc == MEMCACHED_SUCCESS);
4639   }
4640
4641   /*
4642   ** We are using the quiet commands to store the replicas, so we need
4643   ** to ensure that all of them are processed before we can continue.
4644   ** In the test we go directly from storing the object to trying to
4645   ** receive the object from all of the different servers, so we
4646   ** could end up in a race condition (the memcached server hasn't yet
4647   ** processed the quiet command from the replication set when it process
4648   ** the request from the other client (created by the clone)). As a
4649   ** workaround for that we call memcached_quit to send the quit command
4650   ** to the server and wait for the response ;-) If you use the test code
4651   ** as an example for your own code, please note that you shouldn't need
4652   ** to do this ;-)
4653   */
4654   memcached_quit(memc);
4655
4656   /*
4657    * Don't do the following in your code. I am abusing the internal details
4658    * within the library, and this is not a supported interface.
4659    * This is to verify correct behavior in the library
4660    */
4661   memcached_result_st result_obj;
4662   for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
4663   {
4664     memcached_st *new_clone= memcached_clone(NULL, memc);
4665     memcached_server_instance_st instance=
4666       memcached_server_instance_by_position(new_clone, host);
4667     ((memcached_server_write_instance_st)instance)->port= 0;
4668
4669     for (int x= 'a'; x <= 'z'; ++x)
4670     {
4671       char key[2]= { [0]= (char)x, [1]= 0 };
4672
4673       rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
4674       test_true(rc == MEMCACHED_SUCCESS);
4675
4676       memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
4677       test_true(results);
4678
4679       int hits= 0;
4680       while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
4681       {
4682         hits++;
4683       }
4684       test_true(hits == 4);
4685       memcached_result_free(&result_obj);
4686     }
4687
4688     memcached_free(new_clone);
4689   }
4690
4691   memcached_free(memc_clone);
4692
4693   return TEST_SUCCESS;
4694 }
4695
4696 static test_return_t replication_randomize_mget_test(memcached_st *memc)
4697 {
4698   memcached_result_st result_obj;
4699   memcached_return_t rc;
4700   memcached_st *memc_clone= memcached_clone(NULL, memc);
4701   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3);
4702   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1);
4703
4704   const char *keys[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4705   size_t len[]= { 4, 4, 4, 4, 4, 4, 4 };
4706
4707   for (size_t x= 0; x< 7; ++x)
4708   {
4709     rc= memcached_set(memc, keys[x], len[x], "1", 1, 0, 0);
4710     test_true(rc == MEMCACHED_SUCCESS);
4711   }
4712
4713   memcached_quit(memc);
4714
4715   for (size_t x= 0; x< 7; ++x)
4716   {
4717     const char key[2]= { [0]= (const char)x };
4718
4719     rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 7);
4720     test_true(rc == MEMCACHED_SUCCESS);
4721
4722     memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
4723     test_true(results);
4724
4725     int hits= 0;
4726     while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
4727     {
4728       ++hits;
4729     }
4730     test_true(hits == 7);
4731     memcached_result_free(&result_obj);
4732   }
4733   memcached_free(memc_clone);
4734   return TEST_SUCCESS;
4735 }
4736
4737 static test_return_t replication_delete_test(memcached_st *memc)
4738 {
4739   memcached_return_t rc;
4740   memcached_st *memc_clone= memcached_clone(NULL, memc);
4741   /* Delete the items from all of the servers except 1 */
4742   uint64_t repl= memcached_behavior_get(memc,
4743                                         MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
4744   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
4745
4746   const char *keys[]= { "bubba", "key1", "key2", "key3" };
4747   size_t len[]= { 5, 4, 4, 4 };
4748
4749   for (size_t x= 0; x< 4; ++x)
4750   {
4751     rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
4752     test_true(rc == MEMCACHED_SUCCESS);
4753   }
4754
4755   /*
4756    * Don't do the following in your code. I am abusing the internal details
4757    * within the library, and this is not a supported interface.
4758    * This is to verify correct behavior in the library
4759    */
4760   uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
4761   for (uint32_t x= 0; x < (repl + 1); ++x)
4762   {
4763     memcached_server_instance_st instance=
4764       memcached_server_instance_by_position(memc_clone, x);
4765
4766     ((memcached_server_write_instance_st)instance)->port= 0;
4767     if (++hash == memc_clone->number_of_hosts)
4768       hash= 0;
4769   }
4770
4771   memcached_result_st result_obj;
4772   for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
4773   {
4774     for (size_t x= 'a'; x <= 'z'; ++x)
4775     {
4776       const char key[2]= { [0]= (const char)x };
4777
4778       rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
4779       test_true(rc == MEMCACHED_SUCCESS);
4780
4781       memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
4782       test_true(results);
4783
4784       int hits= 0;
4785       while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
4786       {
4787         ++hits;
4788       }
4789       test_true(hits == 4);
4790       memcached_result_free(&result_obj);
4791     }
4792   }
4793   memcached_free(memc_clone);
4794
4795   return TEST_SUCCESS;
4796 }
4797
4798 #if 0
4799 static test_return_t hash_sanity_test (memcached_st *memc)
4800 {
4801   (void)memc;
4802
4803   assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
4804   assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
4805   assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
4806   assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
4807   assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
4808   assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
4809   assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
4810 #ifdef HAVE_HSIEH_HASH
4811   assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
4812 #endif
4813   assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
4814   assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
4815   assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
4816
4817   return TEST_SUCCESS;
4818 }
4819 #endif
4820
4821 static test_return_t hsieh_avaibility_test (memcached_st *memc)
4822 {
4823   memcached_return_t expected_rc= MEMCACHED_FAILURE;
4824 #ifdef HAVE_HSIEH_HASH
4825   expected_rc= MEMCACHED_SUCCESS;
4826 #endif
4827   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4828                                                 (uint64_t)MEMCACHED_HASH_HSIEH);
4829   test_true(rc == expected_rc);
4830
4831   return TEST_SUCCESS;
4832 }
4833
4834 static test_return_t one_at_a_time_run (memcached_st *memc __attribute__((unused)))
4835 {
4836   uint32_t x;
4837   const char **ptr;
4838
4839   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4840   {
4841     uint32_t hash_val;
4842
4843     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
4844     test_true(one_at_a_time_values[x] == hash_val);
4845   }
4846
4847   return TEST_SUCCESS;
4848 }
4849
4850 static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
4851 {
4852   uint32_t x;
4853   const char **ptr;
4854
4855   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4856   {
4857     uint32_t hash_val;
4858
4859     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4860     test_true(md5_values[x] == hash_val);
4861   }
4862
4863   return TEST_SUCCESS;
4864 }
4865
4866 static test_return_t crc_run (memcached_st *memc __attribute__((unused)))
4867 {
4868   uint32_t x;
4869   const char **ptr;
4870
4871   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4872   {
4873     uint32_t hash_val;
4874
4875     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4876     test_true(crc_values[x] == hash_val);
4877   }
4878
4879   return TEST_SUCCESS;
4880 }
4881
4882 static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
4883 {
4884   uint32_t x;
4885   const char **ptr;
4886
4887   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4888   {
4889     uint32_t hash_val;
4890
4891     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4892     test_true(fnv1_64_values[x] == hash_val);
4893   }
4894
4895   return TEST_SUCCESS;
4896 }
4897
4898 static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
4899 {
4900   uint32_t x;
4901   const char **ptr;
4902
4903   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4904   {
4905     uint32_t hash_val;
4906
4907     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4908     test_true(fnv1a_64_values[x] == hash_val);
4909   }
4910
4911   return TEST_SUCCESS;
4912 }
4913
4914 static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
4915 {
4916   uint32_t x;
4917   const char **ptr;
4918
4919
4920   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4921   {
4922     uint32_t hash_val;
4923
4924     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4925     test_true(fnv1_32_values[x] == hash_val);
4926   }
4927
4928   return TEST_SUCCESS;
4929 }
4930
4931 static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
4932 {
4933   uint32_t x;
4934   const char **ptr;
4935
4936   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4937   {
4938     uint32_t hash_val;
4939
4940     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4941     test_true(fnv1a_32_values[x] == hash_val);
4942   }
4943
4944   return TEST_SUCCESS;
4945 }
4946
4947 static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
4948 {
4949   uint32_t x;
4950   const char **ptr;
4951
4952   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4953   {
4954     uint32_t hash_val;
4955
4956     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4957     test_true(hsieh_values[x] == hash_val);
4958   }
4959
4960   return TEST_SUCCESS;
4961 }
4962
4963 static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
4964 {
4965 #ifdef WORDS_BIGENDIAN
4966   return TEST_SKIPPED;
4967 #else
4968   uint32_t x;
4969   const char **ptr;
4970
4971   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4972   {
4973     uint32_t hash_val;
4974
4975     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
4976     test_true(murmur_values[x] == hash_val);
4977   }
4978
4979   return TEST_SUCCESS;
4980 #endif
4981 }
4982
4983 static test_return_t jenkins_run (memcached_st *memc __attribute__((unused)))
4984 {
4985   uint32_t x;
4986   const char **ptr;
4987
4988
4989   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4990   {
4991     uint32_t hash_val;
4992
4993     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4994     test_true(jenkins_values[x] == hash_val);
4995   }
4996
4997   return TEST_SUCCESS;
4998 }
4999
5000 static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
5001 {
5002   (void)context;
5003   return libhashkit_md5(string, string_length);
5004 }
5005
5006 static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
5007 {
5008   (void)context;
5009   return libhashkit_crc32(string, string_length);
5010 }
5011
5012 static test_return_t memcached_get_hashkit_test (memcached_st *memc)
5013 {
5014   uint32_t x;
5015   const char **ptr;
5016   const hashkit_st *kit;
5017   hashkit_st new_kit;
5018   hashkit_return_t hash_rc;
5019
5020   uint32_t md5_hosts[]= {4U, 1U, 0U, 1U, 4U, 2U, 0U, 3U, 0U, 0U, 3U, 1U, 0U, 0U, 1U, 3U, 0U, 0U, 0U, 3U, 1U, 0U, 4U, 4U, 3U};
5021   uint32_t crc_hosts[]= {2U, 4U, 1U, 0U, 2U, 4U, 4U, 4U, 1U, 2U, 3U, 4U, 3U, 4U, 1U, 3U, 3U, 2U, 0U, 0U, 0U, 1U, 2U, 4U, 0U};
5022
5023   kit= memcached_get_hashkit(memc);
5024
5025   hashkit_clone(&new_kit, kit);
5026   hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
5027   test_true(hash_rc == HASHKIT_SUCCESS);
5028
5029   memcached_set_hashkit(memc, &new_kit);
5030
5031   /*
5032     Verify Setting the hash.
5033   */
5034   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5035   {
5036     uint32_t hash_val;
5037
5038     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
5039     test_true(md5_values[x] == hash_val);
5040   }
5041
5042
5043   /*
5044     Now check memcached_st.
5045   */
5046   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5047   {
5048     uint32_t hash_val;
5049
5050     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
5051     test_true(md5_hosts[x] == hash_val);
5052   }
5053
5054   hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
5055   test_true(hash_rc == HASHKIT_SUCCESS);
5056
5057   memcached_set_hashkit(memc, &new_kit);
5058
5059   /*
5060     Verify Setting the hash.
5061   */
5062   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5063   {
5064     uint32_t hash_val;
5065
5066     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
5067     test_true(crc_values[x] == hash_val);
5068   }
5069
5070   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5071   {
5072     uint32_t hash_val;
5073
5074     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
5075     test_true(crc_hosts[x] == hash_val);
5076   }
5077
5078   return TEST_SUCCESS;
5079 }
5080
5081 /*
5082   Test case adapted from John Gorman <johngorman2@gmail.com>
5083
5084   We are testing the error condition when we connect to a server via memcached_get()
5085   but find that the server is not available.
5086 */
5087 static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
5088 {
5089   (void)memc;
5090   memcached_st *tl_memc_h;
5091   memcached_server_st *servers;
5092
5093   const char *key= "MemcachedLives";
5094   size_t len;
5095   uint32_t flags;
5096   memcached_return rc;
5097   char *value;
5098
5099   // Create a handle.
5100   tl_memc_h= memcached_create(NULL);
5101   servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5102   memcached_server_push(tl_memc_h, servers);
5103   memcached_server_list_free(servers);
5104
5105   // See if memcached is reachable.
5106   value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
5107
5108   test_false(value);
5109   test_true(len == 0);
5110   test_false(rc == MEMCACHED_SUCCESS);
5111
5112   memcached_free(tl_memc_h);
5113
5114   return TEST_SUCCESS;
5115 }
5116
5117 /*
5118   We connect to a server which exists, but search for a key that does not exist.
5119 */
5120 static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
5121 {
5122   const char *key= "MemcachedKeyNotEXIST";
5123   size_t len;
5124   uint32_t flags;
5125   memcached_return rc;
5126   char *value;
5127
5128   // See if memcached is reachable.
5129   value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
5130
5131   test_false(value);
5132   test_true(len == 0);
5133   test_true(rc == MEMCACHED_NOTFOUND);
5134
5135   return TEST_SUCCESS;
5136 }
5137
5138 /*
5139   Test case adapted from John Gorman <johngorman2@gmail.com>
5140
5141   We are testing the error condition when we connect to a server via memcached_get_by_key()
5142   but find that the server is not available.
5143 */
5144 static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
5145 {
5146   (void)memc;
5147   memcached_st *tl_memc_h;
5148   memcached_server_st *servers;
5149
5150   const char *key= "MemcachedLives";
5151   size_t len;
5152   uint32_t flags;
5153   memcached_return rc;
5154   char *value;
5155
5156   // Create a handle.
5157   tl_memc_h= memcached_create(NULL);
5158   servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5159   memcached_server_push(tl_memc_h, servers);
5160   memcached_server_list_free(servers);
5161
5162   // See if memcached is reachable.
5163   value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
5164
5165   test_false(value);
5166   test_true(len == 0);
5167   test_false(rc == MEMCACHED_SUCCESS);
5168
5169   memcached_free(tl_memc_h);
5170
5171   return TEST_SUCCESS;
5172 }
5173
5174 /*
5175   We connect to a server which exists, but search for a key that does not exist.
5176 */
5177 static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
5178 {
5179   const char *key= "MemcachedKeyNotEXIST";
5180   size_t len;
5181   uint32_t flags;
5182   memcached_return rc;
5183   char *value;
5184
5185   // See if memcached is reachable.
5186   value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
5187
5188   test_false(value);
5189   test_true(len == 0);
5190   test_true(rc == MEMCACHED_NOTFOUND);
5191
5192   return TEST_SUCCESS;
5193 }
5194
5195
5196 static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
5197 {
5198   memcached_return_t rc;
5199   uint64_t value;
5200   int x;
5201   memcached_server_st *server_pool;
5202   memcached_st *memc;
5203
5204   (void)trash;
5205
5206   memc= memcached_create(NULL);
5207   test_true(memc);
5208
5209   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
5210   test_true(rc == MEMCACHED_SUCCESS);
5211
5212   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
5213   test_true(value == 1);
5214
5215   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
5216   test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
5217
5218
5219   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");
5220   memcached_server_push(memc, server_pool);
5221
5222   /* verify that the server list was parsed okay. */
5223   test_true(memcached_server_count(memc) == 8);
5224   test_strcmp(server_pool[0].hostname, "10.0.1.1");
5225   test_true(server_pool[0].port == 11211);
5226   test_true(server_pool[0].weight == 600);
5227   test_strcmp(server_pool[2].hostname, "10.0.1.3");
5228   test_true(server_pool[2].port == 11211);
5229   test_true(server_pool[2].weight == 200);
5230   test_strcmp(server_pool[7].hostname, "10.0.1.8");
5231   test_true(server_pool[7].port == 11211);
5232   test_true(server_pool[7].weight == 100);
5233
5234   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5235    * us test the boundary wraparound.
5236    */
5237   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
5238
5239   /* verify the standard ketama set. */
5240   for (x= 0; x < 99; x++)
5241   {
5242     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
5243     memcached_server_instance_st instance=
5244       memcached_server_instance_by_position(memc, server_idx);
5245     const char *hostname = memcached_server_name(instance);
5246
5247     test_strcmp(hostname, ketama_test_cases[x].server);
5248   }
5249
5250   memcached_server_list_free(server_pool);
5251   memcached_free(memc);
5252
5253   return TEST_SUCCESS;
5254 }
5255
5256 static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
5257 {
5258   memcached_return_t rc;
5259   uint64_t value;
5260   int x;
5261   memcached_server_st *server_pool;
5262   memcached_st *memc;
5263
5264   (void)trash;
5265
5266   memc= memcached_create(NULL);
5267   test_true(memc);
5268
5269   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
5270   test_true(rc == MEMCACHED_SUCCESS);
5271
5272   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
5273   test_true(value == 1);
5274
5275   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
5276   test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
5277
5278   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");
5279   memcached_server_push(memc, server_pool);
5280
5281   /* verify that the server list was parsed okay. */
5282   test_true(memcached_server_count(memc) == 8);
5283   test_strcmp(server_pool[0].hostname, "10.0.1.1");
5284   test_true(server_pool[0].port == 11211);
5285   test_true(server_pool[0].weight == 600);
5286   test_strcmp(server_pool[2].hostname, "10.0.1.3");
5287   test_true(server_pool[2].port == 11211);
5288   test_true(server_pool[2].weight == 200);
5289   test_strcmp(server_pool[7].hostname, "10.0.1.8");
5290   test_true(server_pool[7].port == 11211);
5291   test_true(server_pool[7].weight == 100);
5292
5293   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5294    * us test the boundary wraparound.
5295    */
5296   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
5297
5298   /* verify the standard ketama set. */
5299   for (x= 0; x < 99; x++)
5300   {
5301     uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
5302
5303     memcached_server_instance_st instance=
5304       memcached_server_instance_by_position(memc, server_idx);
5305
5306     const char *hostname= memcached_server_name(instance);
5307
5308     test_strcmp(hostname, ketama_test_cases_spy[x].server);
5309   }
5310
5311   memcached_server_list_free(server_pool);
5312   memcached_free(memc);
5313
5314   return TEST_SUCCESS;
5315 }
5316
5317 static test_return_t regression_bug_434484(memcached_st *memc)
5318 {
5319   test_return_t test_rc;
5320   test_rc= pre_binary(memc);
5321
5322   if (test_rc != TEST_SUCCESS)
5323     return test_rc;
5324
5325   memcached_return_t ret;
5326   const char *key= "regression_bug_434484";
5327   size_t keylen= strlen(key);
5328
5329   ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
5330   test_true(ret == MEMCACHED_NOTSTORED);
5331
5332   size_t size= 2048 * 1024;
5333   void *data= calloc(1, size);
5334   test_true(data != NULL);
5335   ret= memcached_set(memc, key, keylen, data, size, 0, 0);
5336   test_true(ret == MEMCACHED_E2BIG);
5337   free(data);
5338
5339   return TEST_SUCCESS;
5340 }
5341
5342 static test_return_t regression_bug_434843(memcached_st *memc)
5343 {
5344   test_return_t test_rc;
5345   test_rc= pre_binary(memc);
5346
5347   if (test_rc != TEST_SUCCESS)
5348     return test_rc;
5349
5350   memcached_return_t rc;
5351   size_t counter= 0;
5352   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
5353
5354   /*
5355    * I only want to hit only _one_ server so I know the number of requests I'm
5356    * sending in the pipleine to the server. Let's try to do a multiget of
5357    * 1024 (that should satisfy most users don't you think?). Future versions
5358    * will include a mget_execute function call if you need a higher number.
5359    */
5360   uint32_t number_of_hosts= memcached_server_count(memc);
5361   memc->number_of_hosts= 1;
5362   const size_t max_keys= 1024;
5363   char **keys= calloc(max_keys, sizeof(char*));
5364   size_t *key_length=calloc(max_keys, sizeof(size_t));
5365
5366   for (size_t x= 0; x < max_keys; ++x)
5367   {
5368      char k[251];
5369
5370      key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5371      keys[x]= strdup(k);
5372      test_true(keys[x] != NULL);
5373   }
5374
5375   /*
5376    * Run two times.. the first time we should have 100% cache miss,
5377    * and the second time we should have 100% cache hits
5378    */
5379   for (size_t y= 0; y < 2; y++)
5380   {
5381     rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
5382     test_true(rc == MEMCACHED_SUCCESS);
5383     rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5384
5385     if (y == 0)
5386     {
5387       /* The first iteration should give me a 100% cache miss. verify that*/
5388       char blob[1024]= { 0 };
5389
5390       test_true(counter == 0);
5391
5392       for (size_t x= 0; x < max_keys; ++x)
5393       {
5394         rc= memcached_add(memc, keys[x], key_length[x],
5395                           blob, sizeof(blob), 0, 0);
5396         test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5397       }
5398     }
5399     else
5400     {
5401       /* Verify that we received all of the key/value pairs */
5402        test_true(counter == max_keys);
5403     }
5404   }
5405
5406   /* Release allocated resources */
5407   for (size_t x= 0; x < max_keys; ++x)
5408   {
5409     free(keys[x]);
5410   }
5411   free(keys);
5412   free(key_length);
5413
5414   memc->number_of_hosts= number_of_hosts;
5415
5416   return TEST_SUCCESS;
5417 }
5418
5419 static test_return_t regression_bug_434843_buffered(memcached_st *memc)
5420 {
5421   memcached_return_t rc;
5422   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
5423   test_true(rc == MEMCACHED_SUCCESS);
5424
5425   return regression_bug_434843(memc);
5426 }
5427
5428 static test_return_t regression_bug_421108(memcached_st *memc)
5429 {
5430   memcached_return_t rc;
5431   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
5432   test_true(rc == MEMCACHED_SUCCESS);
5433
5434   char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
5435   test_true(rc == MEMCACHED_SUCCESS);
5436   test_true(bytes != NULL);
5437   char *bytes_read= memcached_stat_get_value(memc, memc_stat,
5438                                              "bytes_read", &rc);
5439   test_true(rc == MEMCACHED_SUCCESS);
5440   test_true(bytes_read != NULL);
5441
5442   char *bytes_written= memcached_stat_get_value(memc, memc_stat,
5443                                                 "bytes_written", &rc);
5444   test_true(rc == MEMCACHED_SUCCESS);
5445   test_true(bytes_written != NULL);
5446
5447   test_true(strcmp(bytes, bytes_read) != 0);
5448   test_true(strcmp(bytes, bytes_written) != 0);
5449
5450   /* Release allocated resources */
5451   free(bytes);
5452   free(bytes_read);
5453   free(bytes_written);
5454   memcached_stat_free(NULL, memc_stat);
5455
5456   return TEST_SUCCESS;
5457 }
5458
5459 /*
5460  * The test case isn't obvious so I should probably document why
5461  * it works the way it does. Bug 442914 was caused by a bug
5462  * in the logic in memcached_purge (it did not handle the case
5463  * where the number of bytes sent was equal to the watermark).
5464  * In this test case, create messages so that we hit that case
5465  * and then disable noreply mode and issue a new command to
5466  * verify that it isn't stuck. If we change the format for the
5467  * delete command or the watermarks, we need to update this
5468  * test....
5469  */
5470 static test_return_t regression_bug_442914(memcached_st *memc)
5471 {
5472   memcached_return_t rc;
5473   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
5474   test_true(rc == MEMCACHED_SUCCESS);
5475   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5476
5477   uint32_t number_of_hosts= memcached_server_count(memc);
5478   memc->number_of_hosts= 1;
5479
5480   char k[250];
5481   size_t len;
5482
5483   for (uint32_t x= 0; x < 250; ++x)
5484   {
5485      len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
5486      rc= memcached_delete(memc, k, len, 0);
5487      test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5488   }
5489
5490   (void)snprintf(k, sizeof(k), "%037u", 251U);
5491   len= strlen(k);
5492
5493   rc= memcached_delete(memc, k, len, 0);
5494   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5495
5496   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
5497   test_true(rc == MEMCACHED_SUCCESS);
5498   rc= memcached_delete(memc, k, len, 0);
5499   test_true(rc == MEMCACHED_NOTFOUND);
5500
5501   memc->number_of_hosts= number_of_hosts;
5502
5503   return TEST_SUCCESS;
5504 }
5505
5506 static test_return_t regression_bug_447342(memcached_st *memc)
5507 {
5508   memcached_server_instance_st instance_one;
5509   memcached_server_instance_st instance_two;
5510
5511   if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
5512     return TEST_SKIPPED;
5513
5514   memcached_return_t rc;
5515
5516   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
5517   test_true(rc == MEMCACHED_SUCCESS);
5518
5519   const size_t max_keys= 100;
5520   char **keys= calloc(max_keys, sizeof(char*));
5521   size_t *key_length= calloc(max_keys, sizeof(size_t));
5522
5523   for (size_t x= 0; x < max_keys; ++x)
5524   {
5525     char k[251];
5526
5527     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5528     keys[x]= strdup(k);
5529     test_true(keys[x] != NULL);
5530     rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
5531     test_true(rc == MEMCACHED_SUCCESS);
5532   }
5533
5534   /*
5535   ** We are using the quiet commands to store the replicas, so we need
5536   ** to ensure that all of them are processed before we can continue.
5537   ** In the test we go directly from storing the object to trying to
5538   ** receive the object from all of the different servers, so we
5539   ** could end up in a race condition (the memcached server hasn't yet
5540   ** processed the quiet command from the replication set when it process
5541   ** the request from the other client (created by the clone)). As a
5542   ** workaround for that we call memcached_quit to send the quit command
5543   ** to the server and wait for the response ;-) If you use the test code
5544   ** as an example for your own code, please note that you shouldn't need
5545   ** to do this ;-)
5546   */
5547   memcached_quit(memc);
5548
5549   /* Verify that all messages are stored, and we didn't stuff too much
5550    * into the servers
5551    */
5552   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5553   test_true(rc == MEMCACHED_SUCCESS);
5554
5555   size_t counter= 0;
5556   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
5557   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5558   /* Verify that we received all of the key/value pairs */
5559   test_true(counter == max_keys);
5560
5561   memcached_quit(memc);
5562   /*
5563    * Don't do the following in your code. I am abusing the internal details
5564    * within the library, and this is not a supported interface.
5565    * This is to verify correct behavior in the library. Fake that two servers
5566    * are dead..
5567    */
5568   instance_one= memcached_server_instance_by_position(memc, 0);
5569   instance_two= memcached_server_instance_by_position(memc, 2);
5570   in_port_t port0= instance_one->port;
5571   in_port_t port2= instance_two->port;
5572
5573   ((memcached_server_write_instance_st)instance_one)->port= 0;
5574   ((memcached_server_write_instance_st)instance_two)->port= 0;
5575
5576   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5577   test_true(rc == MEMCACHED_SUCCESS);
5578
5579   counter= 0;
5580   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5581   test_true(counter == (unsigned int)max_keys);
5582
5583   /* restore the memc handle */
5584   ((memcached_server_write_instance_st)instance_one)->port= port0;
5585   ((memcached_server_write_instance_st)instance_two)->port= port2;
5586
5587   memcached_quit(memc);
5588
5589   /* Remove half of the objects */
5590   for (size_t x= 0; x < max_keys; ++x)
5591   {
5592     if (x & 1)
5593     {
5594       rc= memcached_delete(memc, keys[x], key_length[x], 0);
5595       test_true(rc == MEMCACHED_SUCCESS);
5596     }
5597   }
5598
5599   memcached_quit(memc);
5600   ((memcached_server_write_instance_st)instance_one)->port= 0;
5601   ((memcached_server_write_instance_st)instance_two)->port= 0;
5602
5603   /* now retry the command, this time we should have cache misses */
5604   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5605   test_true(rc == MEMCACHED_SUCCESS);
5606
5607   counter= 0;
5608   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5609   test_true(counter == (unsigned int)(max_keys >> 1));
5610
5611   /* Release allocated resources */
5612   for (size_t x= 0; x < max_keys; ++x)
5613   {
5614     free(keys[x]);
5615   }
5616   free(keys);
5617   free(key_length);
5618
5619   /* restore the memc handle */
5620   ((memcached_server_write_instance_st)instance_one)->port= port0;
5621   ((memcached_server_write_instance_st)instance_two)->port= port2;
5622
5623   return TEST_SUCCESS;
5624 }
5625
5626 static test_return_t regression_bug_463297(memcached_st *memc)
5627 {
5628   memcached_st *memc_clone= memcached_clone(NULL, memc);
5629   test_true(memc_clone != NULL);
5630   test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
5631
5632   memcached_server_instance_st instance=
5633     memcached_server_instance_by_position(memc_clone, 0);
5634
5635   if (instance->major_version > 1 ||
5636       (instance->major_version == 1 &&
5637        instance->minor_version > 2))
5638   {
5639     /* Binary protocol doesn't support deferred delete */
5640     memcached_st *bin_clone= memcached_clone(NULL, memc);
5641     test_true(bin_clone != NULL);
5642     test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
5643     test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5644     memcached_free(bin_clone);
5645
5646     memcached_quit(memc_clone);
5647
5648     /* If we know the server version, deferred delete should fail
5649      * with invalid arguments */
5650     test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5651
5652     /* If we don't know the server version, we should get a protocol error */
5653     memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
5654
5655     /* but there is a bug in some of the memcached servers (1.4) that treats
5656      * the counter as noreply so it doesn't send the proper error message
5657      */
5658     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5659
5660     /* And buffered mode should be disabled and we should get protocol error */
5661     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
5662     rc= memcached_delete(memc, "foo", 3, 1);
5663     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5664
5665     /* Same goes for noreply... */
5666     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
5667     rc= memcached_delete(memc, "foo", 3, 1);
5668     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5669
5670     /* but a normal request should go through (and be buffered) */
5671     test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
5672     test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
5673
5674     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
5675     /* unbuffered noreply should be success */
5676     test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
5677     /* unbuffered with reply should be not found... */
5678     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
5679     test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
5680   }
5681
5682   memcached_free(memc_clone);
5683   return TEST_SUCCESS;
5684 }
5685
5686
5687 /* Test memcached_server_get_last_disconnect
5688  * For a working server set, shall be NULL
5689  * For a set of non existing server, shall not be NULL
5690  */
5691 static test_return_t test_get_last_disconnect(memcached_st *memc)
5692 {
5693   memcached_return_t rc;
5694   memcached_server_instance_st disconnected_server;
5695
5696   /* With the working set of server */
5697   const char *key= "marmotte";
5698   const char *value= "milka";
5699
5700   memcached_reset_last_disconnected_server(memc);
5701   rc= memcached_set(memc, key, strlen(key),
5702                     value, strlen(value),
5703                     (time_t)0, (uint32_t)0);
5704   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5705
5706   disconnected_server = memcached_server_get_last_disconnect(memc);
5707   test_true(disconnected_server == NULL);
5708
5709   /* With a non existing server */
5710   memcached_st *mine;
5711   memcached_server_st *servers;
5712
5713   const char *server_list= "localhost:9";
5714
5715   servers= memcached_servers_parse(server_list);
5716   test_true(servers);
5717   mine= memcached_create(NULL);
5718   rc= memcached_server_push(mine, servers);
5719   test_true(rc == MEMCACHED_SUCCESS);
5720   memcached_server_list_free(servers);
5721   test_true(mine);
5722
5723   rc= memcached_set(mine, key, strlen(key),
5724                     value, strlen(value),
5725                     (time_t)0, (uint32_t)0);
5726   test_true(rc != MEMCACHED_SUCCESS);
5727
5728   disconnected_server= memcached_server_get_last_disconnect(mine);
5729   if (disconnected_server == NULL)
5730   {
5731     fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
5732     abort();
5733   }
5734   test_true(disconnected_server != NULL);
5735   test_true(memcached_server_port(disconnected_server)== 9);
5736   test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
5737
5738   memcached_quit(mine);
5739   memcached_free(mine);
5740
5741   return TEST_SUCCESS;
5742 }
5743
5744 static test_return_t test_verbosity(memcached_st *memc)
5745 {
5746   memcached_verbosity(memc, 3);
5747
5748   return TEST_SUCCESS;
5749 }
5750
5751 static test_return_t test_server_failure(memcached_st *memc)
5752 {
5753   memcached_st *local_memc;
5754   memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
5755
5756   local_memc= memcached_create(NULL);
5757
5758   memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
5759   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
5760
5761   uint32_t server_count= memcached_server_count(local_memc);
5762
5763   test_true(server_count == 1);
5764
5765   // Disable the server
5766   instance= memcached_server_instance_by_position(local_memc, 0);
5767   ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
5768
5769   memcached_return_t rc;
5770   rc= memcached_set(local_memc, "foo", strlen("foo"),
5771                     NULL, 0,
5772                     (time_t)0, (uint32_t)0);
5773   test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
5774
5775   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5776   rc= memcached_set(local_memc, "foo", strlen("foo"),
5777                     NULL, 0,
5778                     (time_t)0, (uint32_t)0);
5779   test_true(rc == MEMCACHED_SUCCESS);
5780
5781
5782   memcached_free(local_memc);
5783
5784   return TEST_SUCCESS;
5785 }
5786
5787 static test_return_t test_cull_servers(memcached_st *memc)
5788 {
5789   uint32_t count = memcached_server_count(memc);
5790
5791   // Do not do this in your code, it is not supported.
5792   memc->servers[1].state.is_dead= true;
5793   memc->state.is_time_for_rebuild= true;
5794
5795   uint32_t new_count= memcached_server_count(memc);
5796   test_true(count == new_count);
5797
5798 #if 0
5799   test_true(count == new_count + 1 );
5800 #endif
5801
5802   return TEST_SUCCESS;
5803 }
5804
5805
5806 static memcached_return_t stat_printer(memcached_server_instance_st server,
5807                                        const char *key, size_t key_length,
5808                                        const char *value, size_t value_length,
5809                                        void *context)
5810 {
5811   (void)server;
5812   (void)context;
5813   (void)key;
5814   (void)key_length;
5815   (void)value;
5816   (void)value_length;
5817
5818   return MEMCACHED_SUCCESS;
5819 }
5820
5821 static test_return_t memcached_stat_execute_test(memcached_st *memc)
5822 {
5823   memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
5824   test_true(rc == MEMCACHED_SUCCESS);
5825
5826   rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
5827   test_true(rc == MEMCACHED_SUCCESS);
5828
5829   rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
5830   test_true(rc == MEMCACHED_SUCCESS);
5831
5832   rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
5833   test_true(rc == MEMCACHED_SUCCESS);
5834
5835   return TEST_SUCCESS;
5836 }
5837
5838 /*
5839  * This test ensures that the failure counter isn't incremented during
5840  * normal termination of the memcached instance.
5841  */
5842 static test_return_t wrong_failure_counter_test(memcached_st *memc)
5843 {
5844   memcached_return_t rc;
5845   memcached_server_instance_st instance;
5846
5847   /* Set value to force connection to the server */
5848   const char *key= "marmotte";
5849   const char *value= "milka";
5850
5851   /*
5852    * Please note that I'm abusing the internal structures in libmemcached
5853    * in a non-portable way and you shouldn't be doing this. I'm only
5854    * doing this in order to verify that the library works the way it should
5855    */
5856   uint32_t number_of_hosts= memcached_server_count(memc);
5857   memc->number_of_hosts= 1;
5858
5859   /* Ensure that we are connected to the server by setting a value */
5860   rc= memcached_set(memc, key, strlen(key),
5861                     value, strlen(value),
5862                     (time_t)0, (uint32_t)0);
5863   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5864
5865
5866   instance= memcached_server_instance_by_position(memc, 0);
5867   /* The test is to see that the memcached_quit doesn't increase the
5868    * the server failure conter, so let's ensure that it is zero
5869    * before sending quit
5870    */
5871   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5872
5873   memcached_quit(memc);
5874
5875   /* Verify that it memcached_quit didn't increment the failure counter
5876    * Please note that this isn't bullet proof, because an error could
5877    * occur...
5878    */
5879   test_true(instance->server_failure_counter == 0);
5880
5881   /* restore the instance */
5882   memc->number_of_hosts= number_of_hosts;
5883
5884   return TEST_SUCCESS;
5885 }
5886
5887
5888
5889
5890 /*
5891  * Test that ensures mget_execute does not end into recursive calls that finally fails
5892  */
5893 static test_return_t regression_bug_490486(memcached_st *memc)
5894 {
5895   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
5896   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
5897   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
5898   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
5899   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
5900
5901 #ifdef __APPLE__
5902   return TEST_SKIPPED; // My MAC can't handle this test
5903 #endif
5904
5905   /*
5906    * I only want to hit _one_ server so I know the number of requests I'm
5907    * sending in the pipeline.
5908    */
5909   uint32_t number_of_hosts= memc->number_of_hosts;
5910   memc->number_of_hosts= 1;
5911   size_t max_keys= 20480;
5912
5913
5914   char **keys= calloc(max_keys, sizeof(char*));
5915   size_t *key_length=calloc(max_keys, sizeof(size_t));
5916
5917   /* First add all of the items.. */
5918   bool slept= false;
5919   char blob[1024]= { 0 };
5920   memcached_return rc;
5921   for (size_t x= 0; x < max_keys; ++x)
5922   {
5923     char k[251];
5924     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5925     keys[x]= strdup(k);
5926     assert(keys[x] != NULL);
5927     rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
5928 #ifdef __APPLE__
5929     if (rc == MEMCACHED_SERVER_MARKED_DEAD)
5930     {
5931       break; // We are out of business
5932     }
5933 #endif
5934     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX
5935
5936     if (rc == MEMCACHED_TIMEOUT && slept == false)
5937     {
5938       x++;
5939       sleep(1);// We will try to sleep
5940       slept= true;
5941     }
5942     else if (rc == MEMCACHED_TIMEOUT && slept == true)
5943     {
5944       // We failed to send everything.
5945       break;
5946     }
5947   }
5948
5949   if (rc != MEMCACHED_SERVER_MARKED_DEAD)
5950   {
5951
5952     /* Try to get all of them with a large multiget */
5953     size_t counter= 0;
5954     memcached_execute_function callbacks[1]= { [0]= &callback_counter };
5955     rc= memcached_mget_execute(memc, (const char**)keys, key_length,
5956                                (size_t)max_keys, callbacks, &counter, 1);
5957
5958     assert(rc == MEMCACHED_SUCCESS);
5959     char* the_value= NULL;
5960     char the_key[MEMCACHED_MAX_KEY];
5961     size_t the_key_length;
5962     size_t the_value_length;
5963     uint32_t the_flags;
5964
5965     do {
5966       the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
5967
5968       if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
5969       {
5970         ++counter;
5971         free(the_value);
5972       }
5973
5974     } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
5975
5976
5977     assert(rc == MEMCACHED_END);
5978
5979     /* Verify that we got all of the items */
5980     assert(counter == max_keys);
5981   }
5982
5983   /* Release all allocated resources */
5984   for (size_t x= 0; x < max_keys; ++x)
5985   {
5986     free(keys[x]);
5987   }
5988   free(keys);
5989   free(key_length);
5990
5991   memc->number_of_hosts= number_of_hosts;
5992
5993   return TEST_SUCCESS;
5994 }
5995
5996 static test_return_t regression_bug_583031(memcached_st *unused)
5997 {
5998   (void)unused;
5999
6000     memcached_st *memc= memcached_create(NULL);
6001     assert(memc);
6002     memcached_server_add(memc, "10.2.3.4", 11211);
6003
6004     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
6005     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
6006     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
6007     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
6008     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
6009     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
6010
6011     memcached_return_t rc;
6012     size_t length;
6013     uint32_t flags;
6014
6015     (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
6016
6017     test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
6018
6019     memcached_free(memc);
6020
6021     return TEST_SUCCESS;
6022 }
6023
6024 static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
6025 {
6026   fprintf(stderr, "Iteration #%u: ", it);
6027
6028   if(error == MEMCACHED_ERRNO)
6029   {
6030     fprintf(stderr, "system error %d from %s: %s\n",
6031             errno, what, strerror(errno));
6032   }
6033   else
6034   {
6035     fprintf(stderr, "error %d from %s: %s\n", error, what,
6036             memcached_strerror(mc, error));
6037   }
6038 }
6039
6040 #define TEST_CONSTANT_CREATION 200
6041
6042 static test_return_t regression_bug_(memcached_st *memc)
6043 {
6044   const char *remote_server;
6045   (void)memc;
6046
6047   if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6048   {
6049     return TEST_SKIPPED;
6050   }
6051
6052   for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
6053   {
6054     memcached_st* mc= memcached_create(NULL);
6055     memcached_return rc;
6056
6057     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
6058     if (rc != MEMCACHED_SUCCESS)
6059     {
6060       memcached_die(mc, rc, "memcached_behavior_set", x);
6061     }
6062
6063     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
6064     if (rc != MEMCACHED_SUCCESS)
6065     {
6066       memcached_die(mc, rc, "memcached_behavior_set", x);
6067     }
6068
6069     rc= memcached_server_add(mc, remote_server, 0);
6070     if (rc != MEMCACHED_SUCCESS)
6071     {
6072       memcached_die(mc, rc, "memcached_server_add", x);
6073     }
6074
6075     const char *set_key= "akey";
6076     const size_t set_key_len= strlen(set_key);
6077     const char *set_value= "a value";
6078     const size_t set_value_len= strlen(set_value);
6079
6080     if (rc == MEMCACHED_SUCCESS)
6081     {
6082       if (x > 0)
6083       {
6084         size_t get_value_len;
6085         char *get_value;
6086         uint32_t get_value_flags;
6087
6088         get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
6089                                  &get_value_flags, &rc);
6090         if (rc != MEMCACHED_SUCCESS)
6091         {
6092           memcached_die(mc, rc, "memcached_get", x);
6093         }
6094         else
6095         {
6096
6097           if (x != 0 &&
6098               (get_value_len != set_value_len
6099                || 0!=strncmp(get_value, set_value, get_value_len)))
6100           {
6101             fprintf(stderr, "Values don't match?\n");
6102             rc= MEMCACHED_FAILURE;
6103           }
6104           free(get_value);
6105         }
6106       }
6107
6108       rc= memcached_set(mc,
6109                         set_key, set_key_len,
6110                         set_value, set_value_len,
6111                         0, /* time */
6112                         0  /* flags */
6113                        );
6114       if (rc != MEMCACHED_SUCCESS)
6115       {
6116         memcached_die(mc, rc, "memcached_set", x);
6117       }
6118     }
6119
6120     memcached_quit(mc);
6121     memcached_free(mc);
6122
6123     if (rc != MEMCACHED_SUCCESS)
6124     {
6125       break;
6126     }
6127   }
6128
6129   return TEST_SUCCESS;
6130 }
6131
6132 /*
6133  * Test that the sasl authentication works. We cannot use the default
6134  * pool of servers, because that would require that all servers we want
6135  * to test supports SASL authentication, and that they use the default
6136  * creds.
6137  */
6138 static test_return_t sasl_auth_test(memcached_st *memc)
6139 {
6140 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6141   memcached_return_t rc;
6142
6143   rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6144   test_true(rc == MEMCACHED_SUCCESS);
6145   test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_SUCCESS);
6146   test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_SUCCESS);
6147   test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_FAILURE);
6148   test_true((rc= memcached_destroy_sasl_auth_data(NULL)) == MEMCACHED_FAILURE);
6149   memcached_quit(memc);
6150
6151   rc= memcached_set_sasl_auth_data(memc,
6152                                    getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6153                                    getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
6154   test_true(rc == MEMCACHED_SUCCESS);
6155
6156   rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6157   test_true(rc == MEMCACHED_AUTH_FAILURE);
6158   test_true(memcached_destroy_sasl_auth_data(memc) == MEMCACHED_SUCCESS);
6159
6160   memcached_quit(memc);
6161   return TEST_SUCCESS;
6162 #else
6163   (void)memc;
6164   return TEST_FAILURE;
6165 #endif
6166 }
6167
6168 /* Clean the server before beginning testing */
6169 test_st tests[] ={
6170   {"util_version", 1, (test_callback_fn)util_version_test },
6171   {"flush", 0, (test_callback_fn)flush_test },
6172   {"init", 0, (test_callback_fn)init_test },
6173   {"allocation", 0, (test_callback_fn)allocation_test },
6174   {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
6175   {"server_unsort", 0, (test_callback_fn)server_unsort_test},
6176   {"server_sort", 0, (test_callback_fn)server_sort_test},
6177   {"server_sort2", 0, (test_callback_fn)server_sort2_test},
6178   {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
6179   {"clone_test", 0, (test_callback_fn)clone_test },
6180   {"connection_test", 0, (test_callback_fn)connection_test},
6181   {"callback_test", 0, (test_callback_fn)callback_test},
6182   {"userdata_test", 0, (test_callback_fn)userdata_test},
6183   {"error", 0, (test_callback_fn)error_test },
6184   {"set", 0, (test_callback_fn)set_test },
6185   {"set2", 0, (test_callback_fn)set_test2 },
6186   {"set3", 0, (test_callback_fn)set_test3 },
6187   {"dump", 1, (test_callback_fn)dump_test},
6188   {"add", 1, (test_callback_fn)add_test },
6189   {"replace", 1, (test_callback_fn)replace_test },
6190   {"delete", 1, (test_callback_fn)delete_test },
6191   {"get", 1, (test_callback_fn)get_test },
6192   {"get2", 0, (test_callback_fn)get_test2 },
6193   {"get3", 0, (test_callback_fn)get_test3 },
6194   {"get4", 0, (test_callback_fn)get_test4 },
6195   {"partial mget", 0, (test_callback_fn)get_test5 },
6196   {"stats_servername", 0, (test_callback_fn)stats_servername_test },
6197   {"increment", 0, (test_callback_fn)increment_test },
6198   {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
6199   {"decrement", 0, (test_callback_fn)decrement_test },
6200   {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
6201   {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
6202   {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
6203   {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
6204   {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
6205   {"quit", 0, (test_callback_fn)quit_test },
6206   {"mget", 1, (test_callback_fn)mget_test },
6207   {"mget_result", 1, (test_callback_fn)mget_result_test },
6208   {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
6209   {"mget_result_function", 1, (test_callback_fn)mget_result_function },
6210   {"mget_execute", 1, (test_callback_fn)mget_execute },
6211   {"mget_end", 0, (test_callback_fn)mget_end },
6212   {"get_stats", 0, (test_callback_fn)get_stats },
6213   {"add_host_test", 0, (test_callback_fn)add_host_test },
6214   {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
6215   {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
6216   {"version_string_test", 0, (test_callback_fn)version_string_test},
6217   {"bad_key", 1, (test_callback_fn)bad_key_test },
6218   {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
6219   {"read_through", 1, (test_callback_fn)read_through },
6220   {"delete_through", 1, (test_callback_fn)delete_through },
6221   {"noreply", 1, (test_callback_fn)noreply_test},
6222   {"analyzer", 1, (test_callback_fn)analyzer_test},
6223 #ifdef HAVE_LIBMEMCACHEDUTIL
6224   {"connectionpool", 1, (test_callback_fn)connection_pool_test },
6225   {"ping", 1, (test_callback_fn)ping_test },
6226 #endif
6227   {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
6228   {"verbosity", 1, (test_callback_fn)test_verbosity},
6229   {"test_server_failure", 1, (test_callback_fn)test_server_failure},
6230   {"cull_servers", 1, (test_callback_fn)test_cull_servers},
6231   {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
6232   {0, 0, 0}
6233 };
6234
6235 test_st behavior_tests[] ={
6236   {"behavior_test", 0, (test_callback_fn)behavior_test},
6237   {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
6238   {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
6239   {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
6240   {0, 0, 0}
6241 };
6242
6243 test_st regression_binary_vs_block[] ={
6244   {"block add", 1, (test_callback_fn)block_add_regression},
6245   {"binary add", 1, (test_callback_fn)binary_add_regression},
6246   {0, 0, 0}
6247 };
6248
6249 test_st async_tests[] ={
6250   {"add", 1, (test_callback_fn)add_wrapper },
6251   {0, 0, 0}
6252 };
6253
6254 test_st string_tests[] ={
6255   {"string static with null", 0, (test_callback_fn)string_static_null },
6256   {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
6257   {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
6258   {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
6259   {"string append", 0, (test_callback_fn)string_alloc_append },
6260   {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
6261   {0, 0, (test_callback_fn)0}
6262 };
6263
6264 test_st result_tests[] ={
6265   {"result static", 0, (test_callback_fn)result_static},
6266   {"result alloc", 0, (test_callback_fn)result_alloc},
6267   {0, 0, (test_callback_fn)0}
6268 };
6269
6270 test_st version_1_2_3[] ={
6271   {"append", 0, (test_callback_fn)append_test },
6272   {"prepend", 0, (test_callback_fn)prepend_test },
6273   {"cas", 0, (test_callback_fn)cas_test },
6274   {"cas2", 0, (test_callback_fn)cas2_test },
6275   {"append_binary", 0, (test_callback_fn)append_binary_test },
6276   {0, 0, (test_callback_fn)0}
6277 };
6278
6279 test_st user_tests[] ={
6280   {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
6281   {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
6282   {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
6283   {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
6284   {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
6285   {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
6286   {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
6287   {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
6288   {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
6289   {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
6290   {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
6291   {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
6292   {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
6293   {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
6294   {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
6295   {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
6296 #if !defined(__sun) && !defined(__OpenBSD__)
6297   /*
6298   ** It seems to be something weird with the character sets..
6299   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6300   ** guess I need to find out how this is supposed to work.. Perhaps I need
6301   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6302   ** so just disable the code for now...).
6303   */
6304   {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
6305 #endif
6306   {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
6307   {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
6308   {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
6309   {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
6310   {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
6311   {0, 0, (test_callback_fn)0}
6312 };
6313
6314 test_st replication_tests[]= {
6315   {"set", 1, (test_callback_fn)replication_set_test },
6316   {"get", 0, (test_callback_fn)replication_get_test },
6317   {"mget", 0, (test_callback_fn)replication_mget_test },
6318   {"delete", 0, (test_callback_fn)replication_delete_test },
6319   {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
6320   {0, 0, (test_callback_fn)0}
6321 };
6322
6323 /*
6324  * The following test suite is used to verify that we don't introduce
6325  * regression bugs. If you want more information about the bug / test,
6326  * you should look in the bug report at
6327  *   http://bugs.launchpad.net/libmemcached
6328  */
6329 test_st regression_tests[]= {
6330   {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
6331   {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
6332   {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
6333   {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
6334   {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
6335   {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
6336   {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
6337   {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
6338   {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
6339   {"lp:?", 1, (test_callback_fn)regression_bug_ },
6340   {0, 0, (test_callback_fn)0}
6341 };
6342
6343 test_st sasl_auth_tests[]= {
6344   {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
6345   {0, 0, (test_callback_fn)0}
6346 };
6347
6348 test_st ketama_compatibility[]= {
6349   {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
6350   {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
6351   {0, 0, (test_callback_fn)0}
6352 };
6353
6354 test_st generate_tests[] ={
6355   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6356   {"generate_data", 1, (test_callback_fn)generate_data },
6357   {"get_read", 0, (test_callback_fn)get_read },
6358   {"delete_generate", 0, (test_callback_fn)delete_generate },
6359   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6360   {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
6361   {"generate_data", 1, (test_callback_fn)generate_data },
6362   {"mget_read", 0, (test_callback_fn)mget_read },
6363   {"mget_read_result", 0, (test_callback_fn)mget_read_result },
6364   {"mget_read_function", 0, (test_callback_fn)mget_read_function },
6365   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6366   {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
6367   {"generate_data", 1, (test_callback_fn)generate_data },
6368   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6369   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6370   {0, 0, (test_callback_fn)0}
6371 };
6372
6373 test_st consistent_tests[] ={
6374   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6375   {"generate_data", 1, (test_callback_fn)generate_data },
6376   {"get_read", 0, (test_callback_fn)get_read_count },
6377   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6378   {0, 0, (test_callback_fn)0}
6379 };
6380
6381 test_st consistent_weighted_tests[] ={
6382   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6383   {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
6384   {"get_read", 0, (test_callback_fn)get_read_count },
6385   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6386   {0, 0, (test_callback_fn)0}
6387 };
6388
6389 test_st hsieh_availability[] ={
6390   {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
6391   {0, 0, (test_callback_fn)0}
6392 };
6393
6394 #if 0
6395 test_st hash_sanity[] ={
6396   {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
6397   {0, 0, (test_callback_fn)0}
6398 };
6399 #endif
6400
6401 test_st ketama_auto_eject_hosts[] ={
6402   {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
6403   {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
6404   {0, 0, (test_callback_fn)0}
6405 };
6406
6407 test_st hash_tests[] ={
6408   {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
6409   {"md5", 0, (test_callback_fn)md5_run },
6410   {"crc", 0, (test_callback_fn)crc_run },
6411   {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
6412   {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
6413   {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
6414   {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
6415   {"hsieh", 0, (test_callback_fn)hsieh_run },
6416   {"murmur", 0, (test_callback_fn)murmur_run },
6417   {"jenkis", 0, (test_callback_fn)jenkins_run },
6418   {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
6419   {0, 0, (test_callback_fn)0}
6420 };
6421
6422 test_st error_conditions[] ={
6423   {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
6424   {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
6425   {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
6426   {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
6427   {0, 0, (test_callback_fn)0}
6428 };
6429
6430 collection_st collection[] ={
6431 #if 0
6432   {"hash_sanity", 0, 0, hash_sanity},
6433 #endif
6434   {"hsieh_availability", 0, 0, hsieh_availability},
6435   {"block", 0, 0, tests},
6436   {"binary", (test_callback_fn)pre_binary, 0, tests},
6437   {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
6438   {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6439   {"settimer", (test_callback_fn)pre_settimer, 0, tests},
6440   {"md5", (test_callback_fn)pre_md5, 0, tests},
6441   {"crc", (test_callback_fn)pre_crc, 0, tests},
6442   {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
6443   {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
6444   {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
6445   {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
6446   {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
6447   {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
6448   {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
6449   {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
6450   {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
6451   {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6452   {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
6453   {"gets", (test_callback_fn)enable_cas, 0, tests},
6454   {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
6455   {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
6456 #ifdef MEMCACHED_ENABLE_DEPRECATED
6457   {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
6458 #endif
6459   {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
6460   {"prefix", (test_callback_fn)set_prefix, 0, tests},
6461   {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
6462   {"sasl", (test_callback_fn)pre_sasl, 0, tests },
6463   {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
6464   {"string", 0, 0, string_tests},
6465   {"result", 0, 0, result_tests},
6466   {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
6467   {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
6468   {"user", 0, 0, user_tests},
6469   {"generate", 0, 0, generate_tests},
6470   {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
6471   {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
6472   {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
6473   {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
6474   {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
6475   {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
6476   {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
6477   // Too slow
6478   {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
6479   {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
6480   {"consistent_not", 0, 0, consistent_tests},
6481   {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
6482   {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
6483   {"ketama_compat", 0, 0, ketama_compatibility},
6484   {"test_hashes", 0, 0, hash_tests},
6485   {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
6486   {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
6487   {"regression", 0, 0, regression_tests},
6488   {"behaviors", 0, 0, behavior_tests},
6489   {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
6490   {"error_conditions", 0, 0, error_conditions},
6491   {0, 0, 0, 0}
6492 };
6493
6494 #define SERVERS_TO_CREATE 5
6495
6496 #include "libmemcached_world.h"
6497
6498 void get_world(world_st *world)
6499 {
6500   world->collections= collection;
6501
6502   world->create= (test_callback_create_fn)world_create;
6503   world->destroy= (test_callback_fn)world_destroy;
6504
6505   world->test.startup= (test_callback_fn)world_test_startup;
6506   world->test.flush= (test_callback_fn)world_flush;
6507   world->test.pre_run= (test_callback_fn)world_pre_run;
6508   world->test.post_run= (test_callback_fn)world_post_run;
6509   world->test.on_error= (test_callback_error_fn)world_on_error;
6510
6511   world->collection.startup= (test_callback_fn)world_container_startup;
6512   world->collection.shutdown= (test_callback_fn)world_container_shutdown;
6513
6514   world->runner= &defualt_libmemcached_runner;
6515 }