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   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3480   if (rc == MEMCACHED_SOME_ERRORS)
3481   {
3482     return TEST_SUCCESS;
3483   }
3484   else if (rc == MEMCACHED_SUCCESS)
3485   {
3486     size_t keys_returned;
3487     test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3488     char buffer[30];
3489     snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
3490     test_true_got(global_count == keys_returned, buffer);
3491   }
3492
3493   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3494
3495   return TEST_SUCCESS;
3496 }
3497
3498 static test_return_t mget_read_result(memcached_st *memc)
3499 {
3500   memcached_return_t rc;
3501
3502   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3503
3504   if (rc == MEMCACHED_SOME_ERRORS)
3505     return TEST_SUCCESS;
3506
3507   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3508   /* Turn this into a help function */
3509   {
3510     memcached_result_st results_obj;
3511     memcached_result_st *results;
3512
3513     results= memcached_result_create(memc, &results_obj);
3514
3515     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
3516     {
3517       test_true(results);
3518       test_true(rc == MEMCACHED_SUCCESS);
3519     }
3520
3521     memcached_result_free(&results_obj);
3522   }
3523
3524   return TEST_SUCCESS;
3525 }
3526
3527 static test_return_t mget_read_function(memcached_st *memc)
3528 {
3529   memcached_return_t rc;
3530   size_t counter;
3531   memcached_execute_fn callbacks[1];
3532
3533   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3534
3535   if (rc == MEMCACHED_SOME_ERRORS)
3536     return TEST_SUCCESS;
3537
3538   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3539
3540   callbacks[0]= &callback_counter;
3541   counter= 0;
3542   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
3543
3544   return TEST_SUCCESS;
3545 }
3546
3547 static test_return_t delete_generate(memcached_st *memc)
3548 {
3549   for (size_t x= 0; x < global_count; x++)
3550   {
3551     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3552   }
3553
3554   return TEST_SUCCESS;
3555 }
3556
3557 static test_return_t delete_buffer_generate(memcached_st *memc)
3558 {
3559   uint64_t latch= 0;
3560
3561   latch= 1;
3562   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3563
3564   for (size_t x= 0; x < global_count; x++)
3565   {
3566     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3567   }
3568
3569   return TEST_SUCCESS;
3570 }
3571
3572 static test_return_t add_host_test1(memcached_st *memc)
3573 {
3574   memcached_return_t rc;
3575   char servername[]= "0.example.com";
3576   memcached_server_st *servers;
3577
3578   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
3579   test_true(servers);
3580   test_true(1 == memcached_server_list_count(servers));
3581
3582   for (size_t x= 2; x < 20; x++)
3583   {
3584     char buffer[SMALL_STRING_LEN];
3585
3586     snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
3587     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
3588                                      &rc);
3589     test_true(rc == MEMCACHED_SUCCESS);
3590     test_true(x == memcached_server_list_count(servers));
3591   }
3592
3593   rc= memcached_server_push(memc, servers);
3594   test_true(rc == MEMCACHED_SUCCESS);
3595   rc= memcached_server_push(memc, servers);
3596   test_true(rc == MEMCACHED_SUCCESS);
3597
3598   memcached_server_list_free(servers);
3599
3600   return TEST_SUCCESS;
3601 }
3602
3603 static test_return_t pre_nonblock(memcached_st *memc)
3604 {
3605   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3606
3607   return TEST_SUCCESS;
3608 }
3609
3610 static test_return_t pre_cork(memcached_st *memc)
3611 {
3612   memcached_return_t rc;
3613   bool set= true;
3614
3615   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
3616
3617 #ifdef __APPLE__
3618   return TEST_SKIPPED;
3619 #endif
3620
3621   if (rc == MEMCACHED_SUCCESS)
3622     return TEST_SUCCESS;
3623
3624   return TEST_SKIPPED;
3625 }
3626
3627 static test_return_t pre_cork_and_nonblock(memcached_st *memc)
3628 {
3629   test_return_t rc;
3630
3631   rc= pre_cork(memc);
3632
3633 #ifdef __APPLE__
3634   return TEST_SKIPPED;
3635 #endif
3636
3637   if (rc != TEST_SUCCESS)
3638     return rc;
3639
3640   return pre_nonblock(memc);
3641 }
3642
3643 static test_return_t pre_nonblock_binary(memcached_st *memc)
3644 {
3645   memcached_return_t rc= MEMCACHED_FAILURE;
3646   memcached_st *memc_clone;
3647
3648   memc_clone= memcached_clone(NULL, memc);
3649   test_true(memc_clone);
3650   // The memcached_version needs to be done on a clone, because the server
3651   // will not toggle protocol on an connection.
3652   memcached_version(memc_clone);
3653
3654   if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
3655   {
3656     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3657     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3658     test_true(rc == MEMCACHED_SUCCESS);
3659     test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3660   }
3661   else
3662   {
3663     return TEST_SKIPPED;
3664   }
3665
3666   memcached_free(memc_clone);
3667
3668   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3669 }
3670
3671 static test_return_t pre_murmur(memcached_st *memc)
3672 {
3673   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3674
3675   return TEST_SUCCESS;
3676 }
3677
3678 static test_return_t pre_jenkins(memcached_st *memc)
3679 {
3680   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
3681
3682   return TEST_SUCCESS;
3683 }
3684
3685
3686 static test_return_t pre_md5(memcached_st *memc)
3687 {
3688   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
3689
3690   return TEST_SUCCESS;
3691 }
3692
3693 static test_return_t pre_crc(memcached_st *memc)
3694 {
3695   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
3696
3697   return TEST_SUCCESS;
3698 }
3699
3700 static test_return_t pre_hsieh(memcached_st *memc)
3701 {
3702 #ifdef HAVE_HSIEH_HASH
3703   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
3704   return TEST_SUCCESS;
3705 #else
3706   (void) memc;
3707   return TEST_SKIPPED;
3708 #endif
3709 }
3710
3711 static test_return_t pre_hash_fnv1_64(memcached_st *memc)
3712 {
3713   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3714
3715   return TEST_SUCCESS;
3716 }
3717
3718 static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
3719 {
3720   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
3721
3722   return TEST_SUCCESS;
3723 }
3724
3725 static test_return_t pre_hash_fnv1_32(memcached_st *memc)
3726 {
3727   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
3728
3729   return TEST_SUCCESS;
3730 }
3731
3732 static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
3733 {
3734   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
3735
3736   return TEST_SUCCESS;
3737 }
3738
3739 static test_return_t pre_behavior_ketama(memcached_st *memc)
3740 {
3741   memcached_return_t rc;
3742   uint64_t value;
3743
3744   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
3745   test_true(rc == MEMCACHED_SUCCESS);
3746
3747   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
3748   test_true(value == 1);
3749
3750   return TEST_SUCCESS;
3751 }
3752
3753 static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
3754 {
3755   memcached_return_t rc;
3756   uint64_t value;
3757
3758   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3759   test_true(rc == MEMCACHED_SUCCESS);
3760
3761   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3762   test_true(value == 1);
3763
3764   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3765   test_true(rc == MEMCACHED_SUCCESS);
3766
3767   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3768   test_true(value == MEMCACHED_HASH_MD5);
3769
3770   return TEST_SUCCESS;
3771 }
3772
3773 /**
3774   @note This should be testing to see if the server really supports the binary protocol.
3775 */
3776 static test_return_t pre_binary(memcached_st *memc)
3777 {
3778   memcached_return_t rc= MEMCACHED_FAILURE;
3779
3780   if (libmemcached_util_version_check(memc, 1, 4, 4))
3781   {
3782     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3783     test_true(rc == MEMCACHED_SUCCESS);
3784     test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3785   }
3786
3787   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3788 }
3789
3790 static test_return_t pre_sasl(memcached_st *memc)
3791 {
3792   memcached_return_t rc= MEMCACHED_FAILURE;
3793
3794 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3795   const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3796   const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3797   const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3798
3799   if (server != NULL && user != NULL && pass != NULL)
3800   {
3801     memcached_server_st *servers= memcached_servers_parse(server);
3802     test_true(servers != NULL);
3803     memcached_servers_reset(memc);
3804     test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
3805     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3806     rc= memcached_set_sasl_auth_data(memc, user, pass);
3807     test_true(rc == MEMCACHED_SUCCESS);
3808   }
3809 #else
3810   (void)memc;
3811 #endif
3812
3813   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3814 }
3815
3816 static test_return_t pre_replication(memcached_st *memc)
3817 {
3818   test_return_t test_rc;
3819   test_rc= pre_binary(memc);
3820
3821   if (test_rc != TEST_SUCCESS)
3822     return test_rc;
3823
3824   /*
3825    * Make sure that we store the item on all servers
3826    * (master + replicas == number of servers)
3827    */
3828   memcached_return_t rc;
3829   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
3830                              memcached_server_count(memc) - 1);
3831   test_true(rc == MEMCACHED_SUCCESS);
3832   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
3833
3834   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3835 }
3836
3837
3838 static test_return_t pre_replication_noblock(memcached_st *memc)
3839 {
3840   test_return_t rc;
3841
3842   rc= pre_replication(memc);
3843   if (rc != TEST_SUCCESS)
3844     return rc;
3845
3846   rc= pre_nonblock(memc);
3847
3848   return rc;
3849 }
3850
3851
3852 static void my_free(const memcached_st *ptr __attribute__((unused)), void *mem, void *context)
3853 {
3854   (void) context;
3855 #ifdef HARD_MALLOC_TESTS
3856   void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
3857   free(real_ptr);
3858 #else
3859   free(mem);
3860 #endif
3861 }
3862
3863
3864 static void *my_malloc(const memcached_st *ptr __attribute__((unused)), const size_t size, void *context)
3865 {
3866   (void)context;
3867 #ifdef HARD_MALLOC_TESTS
3868   void *ret= malloc(size + 8);
3869   if (ret != NULL)
3870   {
3871     ret= (void*)((caddr_t)ret + 8);
3872   }
3873 #else
3874   void *ret= malloc(size);
3875 #endif
3876
3877   if (ret != NULL)
3878   {
3879     memset(ret, 0xff, size);
3880   }
3881
3882   return ret;
3883 }
3884
3885
3886 static void *my_realloc(const memcached_st *ptr __attribute__((unused)), void *mem, const size_t size, void *context)
3887 {
3888   (void)context;
3889 #ifdef HARD_MALLOC_TESTS
3890   void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
3891   void *nmem= realloc(real_ptr, size + 8);
3892
3893   void *ret= NULL;
3894   if (nmem != NULL)
3895   {
3896     ret= (void*)((caddr_t)nmem + 8);
3897   }
3898
3899   return ret;
3900 #else
3901   return realloc(mem, size);
3902 #endif
3903 }
3904
3905
3906 static void *my_calloc(const memcached_st *ptr __attribute__((unused)), size_t nelem, const size_t size, void *context)
3907 {
3908   (void)context;
3909 #ifdef HARD_MALLOC_TESTS
3910   void *mem= my_malloc(ptr, nelem * size);
3911   if (mem)
3912   {
3913     memset(mem, 0, nelem * size);
3914   }
3915
3916   return mem;
3917 #else
3918   return calloc(nelem, size);
3919 #endif
3920 }
3921
3922
3923 static test_return_t set_prefix(memcached_st *memc)
3924 {
3925   memcached_return_t rc;
3926   const char *key= "mine";
3927   char *value;
3928
3929   /* Make sure be default none exists */
3930   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3931   test_true(rc == MEMCACHED_FAILURE);
3932
3933   /* Test a clean set */
3934   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3935   test_true(rc == MEMCACHED_SUCCESS);
3936
3937   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3938   test_true(memcmp(value, key, 4) == 0);
3939   test_true(rc == MEMCACHED_SUCCESS);
3940
3941   /* Test that we can turn it off */
3942   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3943   test_true(rc == MEMCACHED_SUCCESS);
3944
3945   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3946   test_true(rc == MEMCACHED_FAILURE);
3947
3948   /* Now setup for main test */
3949   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3950   test_true(rc == MEMCACHED_SUCCESS);
3951
3952   value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3953   test_true(rc == MEMCACHED_SUCCESS);
3954   test_true(memcmp(value, key, 4) == 0);
3955
3956   /* Set to Zero, and then Set to something too large */
3957   {
3958     char long_key[255];
3959     memset(long_key, 0, 255);
3960
3961     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3962     test_true(rc == MEMCACHED_SUCCESS);
3963
3964     value= memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3965     test_true(rc == MEMCACHED_FAILURE);
3966     test_true(value == NULL);
3967
3968     /* Test a long key for failure */
3969     /* TODO, extend test to determine based on setting, what result should be */
3970     strcpy(long_key, "Thisismorethentheallottednumberofcharacters");
3971     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3972     //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3973     test_true(rc == MEMCACHED_SUCCESS);
3974
3975     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3976     strcpy(long_key, "This is more then the allotted number of characters");
3977     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3978     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3979
3980     /* Test for a bad prefix, but with a short key */
3981     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3982     test_true(rc == MEMCACHED_SUCCESS);
3983
3984     strcpy(long_key, "dog cat");
3985     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3986     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3987   }
3988
3989   return TEST_SUCCESS;
3990 }
3991
3992
3993 #ifdef MEMCACHED_ENABLE_DEPRECATED
3994 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
3995 {
3996   void *test_ptr= NULL;
3997   void *cb_ptr= NULL;
3998   {
3999     memcached_malloc_fn malloc_cb=
4000       (memcached_malloc_fn)my_malloc;
4001     cb_ptr= *(void **)&malloc_cb;
4002     memcached_return_t rc;
4003
4004     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
4005     test_true(rc == MEMCACHED_SUCCESS);
4006     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
4007     test_true(rc == MEMCACHED_SUCCESS);
4008     test_true(test_ptr == cb_ptr);
4009   }
4010
4011   {
4012     memcached_realloc_fn realloc_cb=
4013       (memcached_realloc_fn)my_realloc;
4014     cb_ptr= *(void **)&realloc_cb;
4015     memcached_return_t rc;
4016
4017     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
4018     test_true(rc == MEMCACHED_SUCCESS);
4019     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
4020     test_true(rc == MEMCACHED_SUCCESS);
4021     test_true(test_ptr == cb_ptr);
4022   }
4023
4024   {
4025     memcached_free_fn free_cb=
4026       (memcached_free_fn)my_free;
4027     cb_ptr= *(void **)&free_cb;
4028     memcached_return_t rc;
4029
4030     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
4031     test_true(rc == MEMCACHED_SUCCESS);
4032     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
4033     test_true(rc == MEMCACHED_SUCCESS);
4034     test_true(test_ptr == cb_ptr);
4035   }
4036
4037   return TEST_SUCCESS;
4038 }
4039 #endif
4040
4041
4042 static test_return_t set_memory_alloc(memcached_st *memc)
4043 {
4044   memcached_return_t rc;
4045   rc= memcached_set_memory_allocators(memc, NULL, my_free,
4046                                       my_realloc, my_calloc, NULL);
4047   test_true(rc == MEMCACHED_FAILURE);
4048
4049   rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
4050                                       my_realloc, my_calloc, NULL);
4051
4052   memcached_malloc_fn mem_malloc;
4053   memcached_free_fn mem_free;
4054   memcached_realloc_fn mem_realloc;
4055   memcached_calloc_fn mem_calloc;
4056   memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
4057                                   &mem_realloc, &mem_calloc);
4058
4059   test_true(mem_malloc == my_malloc);
4060   test_true(mem_realloc == my_realloc);
4061   test_true(mem_calloc == my_calloc);
4062   test_true(mem_free == my_free);
4063
4064   return TEST_SUCCESS;
4065 }
4066
4067 static test_return_t enable_consistent_crc(memcached_st *memc)
4068 {
4069   test_return_t rc;
4070   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
4071   memcached_hash_t hash;
4072   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
4073   if ((rc= pre_crc(memc)) != TEST_SUCCESS)
4074     return rc;
4075
4076   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
4077   test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
4078
4079   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
4080
4081   if (hash != MEMCACHED_HASH_CRC)
4082     return TEST_SKIPPED;
4083
4084   return TEST_SUCCESS;
4085 }
4086
4087 static test_return_t enable_consistent_hsieh(memcached_st *memc)
4088 {
4089   test_return_t rc;
4090   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
4091   memcached_hash_t hash;
4092   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
4093   if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
4094     return rc;
4095
4096   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
4097   test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
4098
4099   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
4100
4101   if (hash != MEMCACHED_HASH_HSIEH)
4102     return TEST_SKIPPED;
4103
4104
4105   return TEST_SUCCESS;
4106 }
4107
4108 static test_return_t enable_cas(memcached_st *memc)
4109 {
4110   unsigned int set= 1;
4111
4112   if (libmemcached_util_version_check(memc, 1, 2, 4))
4113   {
4114     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
4115
4116     return TEST_SUCCESS;
4117   }
4118
4119   return TEST_SKIPPED;
4120 }
4121
4122 static test_return_t check_for_1_2_3(memcached_st *memc)
4123 {
4124   memcached_version(memc);
4125
4126   memcached_server_instance_st instance=
4127     memcached_server_instance_by_position(memc, 0);
4128
4129   if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
4130       || instance->minor_version > 2)
4131   {
4132     return TEST_SUCCESS;
4133   }
4134
4135   return TEST_SKIPPED;
4136 }
4137
4138 static test_return_t pre_unix_socket(memcached_st *memc)
4139 {
4140   memcached_return_t rc;
4141   struct stat buf;
4142
4143   memcached_servers_reset(memc);
4144
4145   if (stat("/tmp/memcached.socket", &buf))
4146     return TEST_SKIPPED;
4147
4148   rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
4149
4150   return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
4151 }
4152
4153 static test_return_t pre_nodelay(memcached_st *memc)
4154 {
4155   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
4156   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
4157
4158   return TEST_SUCCESS;
4159 }
4160
4161 static test_return_t pre_settimer(memcached_st *memc)
4162 {
4163   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
4164   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
4165
4166   return TEST_SUCCESS;
4167 }
4168
4169 static test_return_t poll_timeout(memcached_st *memc)
4170 {
4171   size_t timeout;
4172
4173   timeout= 100;
4174
4175   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
4176
4177   timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
4178
4179   test_true(timeout == 100);
4180
4181   return TEST_SUCCESS;
4182 }
4183
4184 static test_return_t noreply_test(memcached_st *memc)
4185 {
4186   memcached_return_t ret;
4187   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
4188   test_true(ret == MEMCACHED_SUCCESS);
4189   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4190   test_true(ret == MEMCACHED_SUCCESS);
4191   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
4192   test_true(ret == MEMCACHED_SUCCESS);
4193   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
4194   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
4195   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
4196
4197   for (int count=0; count < 5; ++count)
4198   {
4199     for (size_t x= 0; x < 100; ++x)
4200     {
4201       char key[10];
4202       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4203       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4204
4205       size_t len= (size_t)check_length;
4206
4207       switch (count)
4208       {
4209       case 0:
4210         ret= memcached_add(memc, key, len, key, len, 0, 0);
4211         break;
4212       case 1:
4213         ret= memcached_replace(memc, key, len, key, len, 0, 0);
4214         break;
4215       case 2:
4216         ret= memcached_set(memc, key, len, key, len, 0, 0);
4217         break;
4218       case 3:
4219         ret= memcached_append(memc, key, len, key, len, 0, 0);
4220         break;
4221       case 4:
4222         ret= memcached_prepend(memc, key, len, key, len, 0, 0);
4223         break;
4224       default:
4225         test_true(count);
4226         break;
4227       }
4228       test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
4229     }
4230
4231     /*
4232     ** NOTE: Don't ever do this in your code! this is not a supported use of the
4233     ** API and is _ONLY_ done this way to verify that the library works the
4234     ** way it is supposed to do!!!!
4235     */
4236     int no_msg=0;
4237     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
4238     {
4239       memcached_server_instance_st instance=
4240         memcached_server_instance_by_position(memc, x);
4241       no_msg+=(int)(instance->cursor_active);
4242     }
4243
4244     test_true(no_msg == 0);
4245     test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4246
4247     /*
4248      ** Now validate that all items was set properly!
4249      */
4250     for (size_t x= 0; x < 100; ++x)
4251     {
4252       char key[10];
4253
4254       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4255
4256       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4257
4258       size_t len= (size_t)check_length;
4259       size_t length;
4260       uint32_t flags;
4261       char* value=memcached_get(memc, key, strlen(key),
4262                                 &length, &flags, &ret);
4263       test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4264       switch (count)
4265       {
4266       case 0: /* FALLTHROUGH */
4267       case 1: /* FALLTHROUGH */
4268       case 2:
4269         test_true(strncmp(value, key, len) == 0);
4270         test_true(len == length);
4271         break;
4272       case 3:
4273         test_true(length == len * 2);
4274         break;
4275       case 4:
4276         test_true(length == len * 3);
4277         break;
4278       default:
4279         test_true(count);
4280         break;
4281       }
4282       free(value);
4283     }
4284   }
4285
4286   /* Try setting an illegal cas value (should not return an error to
4287    * the caller (because we don't expect a return message from the server)
4288    */
4289   const char* keys[]= {"0"};
4290   size_t lengths[]= {1};
4291   size_t length;
4292   uint32_t flags;
4293   memcached_result_st results_obj;
4294   memcached_result_st *results;
4295   ret= memcached_mget(memc, keys, lengths, 1);
4296   test_true(ret == MEMCACHED_SUCCESS);
4297
4298   results= memcached_result_create(memc, &results_obj);
4299   test_true(results);
4300   results= memcached_fetch_result(memc, &results_obj, &ret);
4301   test_true(results);
4302   test_true(ret == MEMCACHED_SUCCESS);
4303   uint64_t cas= memcached_result_cas(results);
4304   memcached_result_free(&results_obj);
4305
4306   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4307   test_true(ret == MEMCACHED_SUCCESS);
4308
4309   /*
4310    * The item will have a new cas value, so try to set it again with the old
4311    * value. This should fail!
4312    */
4313   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4314   test_true(ret == MEMCACHED_SUCCESS);
4315   test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4316   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
4317   test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4318   free(value);
4319
4320   return TEST_SUCCESS;
4321 }
4322
4323 static test_return_t analyzer_test(memcached_st *memc)
4324 {
4325   memcached_return_t rc;
4326   memcached_stat_st *memc_stat;
4327   memcached_analysis_st *report;
4328
4329   memc_stat= memcached_stat(memc, NULL, &rc);
4330   test_true(rc == MEMCACHED_SUCCESS);
4331   test_true(memc_stat);
4332
4333   report= memcached_analyze(memc, memc_stat, &rc);
4334   test_true(rc == MEMCACHED_SUCCESS);
4335   test_true(report);
4336
4337   free(report);
4338   memcached_stat_free(NULL, memc_stat);
4339
4340   return TEST_SUCCESS;
4341 }
4342
4343 /* Count the objects */
4344 static memcached_return_t callback_dump_counter(const memcached_st *ptr __attribute__((unused)),
4345                                                 const char *key __attribute__((unused)),
4346                                                 size_t key_length __attribute__((unused)),
4347                                                 void *context)
4348 {
4349   size_t *counter= (size_t *)context;
4350
4351   *counter= *counter + 1;
4352
4353   return MEMCACHED_SUCCESS;
4354 }
4355
4356 static test_return_t dump_test(memcached_st *memc)
4357 {
4358   memcached_return_t rc;
4359   size_t counter= 0;
4360   memcached_dump_fn callbacks[1];
4361   test_return_t main_rc;
4362
4363   callbacks[0]= &callback_dump_counter;
4364
4365   /* No support for Binary protocol yet */
4366   if (memc->flags.binary_protocol)
4367     return TEST_SUCCESS;
4368
4369   main_rc= set_test3(memc);
4370
4371   test_true (main_rc == TEST_SUCCESS);
4372
4373   rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
4374   test_true(rc == MEMCACHED_SUCCESS);
4375
4376   /* We may have more then 32 if our previous flush has not completed */
4377   test_true(counter >= 32);
4378
4379   return TEST_SUCCESS;
4380 }
4381
4382 #ifdef HAVE_LIBMEMCACHEDUTIL
4383 static void* connection_release(void *arg)
4384 {
4385   struct {
4386     memcached_pool_st* pool;
4387     memcached_st* mmc;
4388   } *resource= arg;
4389
4390   usleep(250);
4391   assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
4392   return arg;
4393 }
4394
4395 #define POOL_SIZE 10
4396 static test_return_t connection_pool_test(memcached_st *memc)
4397 {
4398   memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
4399   test_true(pool != NULL);
4400   memcached_st *mmc[POOL_SIZE];
4401   memcached_return_t rc;
4402
4403   for (size_t x= 0; x < POOL_SIZE; ++x)
4404   {
4405     mmc[x]= memcached_pool_pop(pool, false, &rc);
4406     test_true(mmc[x] != NULL);
4407     test_true(rc == MEMCACHED_SUCCESS);
4408   }
4409
4410   test_true(memcached_pool_pop(pool, false, &rc) == NULL);
4411   test_true(rc == MEMCACHED_SUCCESS);
4412
4413   pthread_t tid;
4414   struct {
4415     memcached_pool_st* pool;
4416     memcached_st* mmc;
4417   } item= { .pool = pool, .mmc = mmc[9] };
4418   pthread_create(&tid, NULL, connection_release, &item);
4419   mmc[9]= memcached_pool_pop(pool, true, &rc);
4420   test_true(rc == MEMCACHED_SUCCESS);
4421   pthread_join(tid, NULL);
4422   test_true(mmc[9] == item.mmc);
4423   const char *key= "key";
4424   size_t keylen= strlen(key);
4425
4426   // verify that I can do ops with all connections
4427   rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
4428   test_true(rc == MEMCACHED_SUCCESS);
4429
4430   for (size_t x= 0; x < POOL_SIZE; ++x)
4431   {
4432     uint64_t number_value;
4433     rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
4434     test_true(rc == MEMCACHED_SUCCESS);
4435     test_true(number_value == (x+1));
4436   }
4437
4438   // Release them..
4439   for (size_t x= 0; x < POOL_SIZE; ++x)
4440   {
4441     test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
4442   }
4443
4444
4445   /* verify that I can set behaviors on the pool when I don't have all
4446    * of the connections in the pool. It should however be enabled
4447    * when I push the item into the pool
4448    */
4449   mmc[0]= memcached_pool_pop(pool, false, &rc);
4450   test_true(mmc[0] != NULL);
4451
4452   rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
4453   test_true(rc == MEMCACHED_SUCCESS);
4454
4455   mmc[1]= memcached_pool_pop(pool, false, &rc);
4456   test_true(mmc[1] != NULL);
4457
4458   test_true(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4459   test_true(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
4460   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4461
4462   mmc[0]= memcached_pool_pop(pool, false, &rc);
4463   test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4464   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4465
4466   test_true(memcached_pool_destroy(pool) == memc);
4467
4468   return TEST_SUCCESS;
4469 }
4470
4471 static test_return_t util_version_test(memcached_st *memc)
4472 {
4473   bool if_successful;
4474
4475   if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
4476   test_true(if_successful == true);
4477
4478   if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
4479
4480   // We expect failure
4481   if (if_successful)
4482   {
4483     fprintf(stderr, "\n----------------------------------------------------------------------\n");
4484     fprintf(stderr, "\nDumping Server Information\n\n");
4485     memcached_server_fn callbacks[1];
4486
4487     callbacks[0]= dump_server_information;
4488     memcached_server_cursor(memc, callbacks, (void *)stderr,  1);
4489     fprintf(stderr, "\n----------------------------------------------------------------------\n");
4490   }
4491   test_true(if_successful == false);
4492
4493   memcached_server_instance_st instance=
4494     memcached_server_instance_by_position(memc, 0);
4495
4496   memcached_version(memc);
4497
4498   // We only use one binary when we test, so this should be just fine.
4499   if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
4500   test_true(if_successful == true);
4501
4502   if (instance->micro_version > 0)
4503     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
4504   else if (instance->minor_version > 0)
4505     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
4506   else if (instance->major_version > 0)
4507     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
4508
4509   test_true(if_successful == true);
4510
4511   if (instance->micro_version > 0)
4512     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
4513   else if (instance->minor_version > 0)
4514     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
4515   else if (instance->major_version > 0)
4516     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
4517
4518   test_true(if_successful == false);
4519
4520   return TEST_SUCCESS;
4521 }
4522
4523 static test_return_t ping_test(memcached_st *memc)
4524 {
4525   memcached_return_t rc;
4526   memcached_server_instance_st instance=
4527     memcached_server_instance_by_position(memc, 0);
4528
4529   // Test both the version that returns a code, and the one that does not.
4530   test_true(libmemcached_util_ping(memcached_server_name(instance),
4531                                    memcached_server_port(instance), NULL));
4532
4533   test_true(libmemcached_util_ping(memcached_server_name(instance),
4534                                    memcached_server_port(instance), &rc));
4535
4536   test_true(rc == MEMCACHED_SUCCESS);
4537
4538   return TEST_SUCCESS;
4539 }
4540 #endif
4541
4542 static test_return_t replication_set_test(memcached_st *memc)
4543 {
4544   memcached_return_t rc;
4545   memcached_st *memc_clone= memcached_clone(NULL, memc);
4546   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
4547
4548   rc= memcached_set(memc, "bubba", 5, "0", 1, 0, 0);
4549   test_true(rc == MEMCACHED_SUCCESS);
4550
4551   /*
4552   ** We are using the quiet commands to store the replicas, so we need
4553   ** to ensure that all of them are processed before we can continue.
4554   ** In the test we go directly from storing the object to trying to
4555   ** receive the object from all of the different servers, so we
4556   ** could end up in a race condition (the memcached server hasn't yet
4557   ** processed the quiet command from the replication set when it process
4558   ** the request from the other client (created by the clone)). As a
4559   ** workaround for that we call memcached_quit to send the quit command
4560   ** to the server and wait for the response ;-) If you use the test code
4561   ** as an example for your own code, please note that you shouldn't need
4562   ** to do this ;-)
4563   */
4564   memcached_quit(memc);
4565
4566   /*
4567   ** "bubba" should now be stored on all of our servers. We don't have an
4568   ** easy to use API to address each individual server, so I'll just iterate
4569   ** through a bunch of "master keys" and I should most likely hit all of the
4570   ** servers...
4571   */
4572   for (int x= 'a'; x <= 'z'; ++x)
4573   {
4574     char key[2]= { [0]= (char)x };
4575     size_t len;
4576     uint32_t flags;
4577     char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
4578                                     &len, &flags, &rc);
4579     test_true(rc == MEMCACHED_SUCCESS);
4580     test_true(val != NULL);
4581     free(val);
4582   }
4583
4584   memcached_free(memc_clone);
4585
4586   return TEST_SUCCESS;
4587 }
4588
4589 static test_return_t replication_get_test(memcached_st *memc)
4590 {
4591   memcached_return_t rc;
4592
4593   /*
4594    * Don't do the following in your code. I am abusing the internal details
4595    * within the library, and this is not a supported interface.
4596    * This is to verify correct behavior in the library
4597    */
4598   for (uint32_t host= 0; host < memcached_server_count(memc); ++host)
4599   {
4600     memcached_st *memc_clone= memcached_clone(NULL, memc);
4601     memcached_server_instance_st instance=
4602       memcached_server_instance_by_position(memc_clone, host);
4603
4604     ((memcached_server_write_instance_st)instance)->port= 0;
4605
4606     for (int x= 'a'; x <= 'z'; ++x)
4607     {
4608       char key[2]= { [0]= (char)x };
4609       size_t len;
4610       uint32_t flags;
4611       char *val= memcached_get_by_key(memc_clone, key, 1, "bubba", 5,
4612                                       &len, &flags, &rc);
4613       test_true(rc == MEMCACHED_SUCCESS);
4614       test_true(val != NULL);
4615       free(val);
4616     }
4617
4618     memcached_free(memc_clone);
4619   }
4620
4621   return TEST_SUCCESS;
4622 }
4623
4624 static test_return_t replication_mget_test(memcached_st *memc)
4625 {
4626   memcached_return_t rc;
4627   memcached_st *memc_clone= memcached_clone(NULL, memc);
4628   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 0);
4629
4630   const char *keys[]= { "bubba", "key1", "key2", "key3" };
4631   size_t len[]= { 5, 4, 4, 4 };
4632
4633   for (size_t x= 0; x< 4; ++x)
4634   {
4635     rc= memcached_set(memc, keys[x], len[x], "0", 1, 0, 0);
4636     test_true(rc == MEMCACHED_SUCCESS);
4637   }
4638
4639   /*
4640   ** We are using the quiet commands to store the replicas, so we need
4641   ** to ensure that all of them are processed before we can continue.
4642   ** In the test we go directly from storing the object to trying to
4643   ** receive the object from all of the different servers, so we
4644   ** could end up in a race condition (the memcached server hasn't yet
4645   ** processed the quiet command from the replication set when it process
4646   ** the request from the other client (created by the clone)). As a
4647   ** workaround for that we call memcached_quit to send the quit command
4648   ** to the server and wait for the response ;-) If you use the test code
4649   ** as an example for your own code, please note that you shouldn't need
4650   ** to do this ;-)
4651   */
4652   memcached_quit(memc);
4653
4654   /*
4655    * Don't do the following in your code. I am abusing the internal details
4656    * within the library, and this is not a supported interface.
4657    * This is to verify correct behavior in the library
4658    */
4659   memcached_result_st result_obj;
4660   for (uint32_t host= 0; host < memc_clone->number_of_hosts; host++)
4661   {
4662     memcached_st *new_clone= memcached_clone(NULL, memc);
4663     memcached_server_instance_st instance=
4664       memcached_server_instance_by_position(new_clone, host);
4665     ((memcached_server_write_instance_st)instance)->port= 0;
4666
4667     for (int x= 'a'; x <= 'z'; ++x)
4668     {
4669       char key[2]= { [0]= (char)x, [1]= 0 };
4670
4671       rc= memcached_mget_by_key(new_clone, key, 1, keys, len, 4);
4672       test_true(rc == MEMCACHED_SUCCESS);
4673
4674       memcached_result_st *results= memcached_result_create(new_clone, &result_obj);
4675       test_true(results);
4676
4677       int hits= 0;
4678       while ((results= memcached_fetch_result(new_clone, &result_obj, &rc)) != NULL)
4679       {
4680         hits++;
4681       }
4682       test_true(hits == 4);
4683       memcached_result_free(&result_obj);
4684     }
4685
4686     memcached_free(new_clone);
4687   }
4688
4689   memcached_free(memc_clone);
4690
4691   return TEST_SUCCESS;
4692 }
4693
4694 static test_return_t replication_randomize_mget_test(memcached_st *memc)
4695 {
4696   memcached_result_st result_obj;
4697   memcached_return_t rc;
4698   memcached_st *memc_clone= memcached_clone(NULL, memc);
4699   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 3);
4700   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RANDOMIZE_REPLICA_READ, 1);
4701
4702   const char *keys[]= { "key1", "key2", "key3", "key4", "key5", "key6", "key7" };
4703   size_t len[]= { 4, 4, 4, 4, 4, 4, 4 };
4704
4705   for (size_t x= 0; x< 7; ++x)
4706   {
4707     rc= memcached_set(memc, keys[x], len[x], "1", 1, 0, 0);
4708     test_true(rc == MEMCACHED_SUCCESS);
4709   }
4710
4711   memcached_quit(memc);
4712
4713   for (size_t x= 0; x< 7; ++x)
4714   {
4715     const char key[2]= { [0]= (const char)x };
4716
4717     rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 7);
4718     test_true(rc == MEMCACHED_SUCCESS);
4719
4720     memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
4721     test_true(results);
4722
4723     int hits= 0;
4724     while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
4725     {
4726       ++hits;
4727     }
4728     test_true(hits == 7);
4729     memcached_result_free(&result_obj);
4730   }
4731   memcached_free(memc_clone);
4732   return TEST_SUCCESS;
4733 }
4734
4735 static test_return_t replication_delete_test(memcached_st *memc)
4736 {
4737   memcached_return_t rc;
4738   memcached_st *memc_clone= memcached_clone(NULL, memc);
4739   /* Delete the items from all of the servers except 1 */
4740   uint64_t repl= memcached_behavior_get(memc,
4741                                         MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
4742   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, --repl);
4743
4744   const char *keys[]= { "bubba", "key1", "key2", "key3" };
4745   size_t len[]= { 5, 4, 4, 4 };
4746
4747   for (size_t x= 0; x< 4; ++x)
4748   {
4749     rc= memcached_delete_by_key(memc, keys[0], len[0], keys[x], len[x], 0);
4750     test_true(rc == MEMCACHED_SUCCESS);
4751   }
4752
4753   /*
4754    * Don't do the following in your code. I am abusing the internal details
4755    * within the library, and this is not a supported interface.
4756    * This is to verify correct behavior in the library
4757    */
4758   uint32_t hash= memcached_generate_hash(memc, keys[0], len[0]);
4759   for (uint32_t x= 0; x < (repl + 1); ++x)
4760   {
4761     memcached_server_instance_st instance=
4762       memcached_server_instance_by_position(memc_clone, x);
4763
4764     ((memcached_server_write_instance_st)instance)->port= 0;
4765     if (++hash == memc_clone->number_of_hosts)
4766       hash= 0;
4767   }
4768
4769   memcached_result_st result_obj;
4770   for (uint32_t host= 0; host < memc_clone->number_of_hosts; ++host)
4771   {
4772     for (size_t x= 'a'; x <= 'z'; ++x)
4773     {
4774       const char key[2]= { [0]= (const char)x };
4775
4776       rc= memcached_mget_by_key(memc_clone, key, 1, keys, len, 4);
4777       test_true(rc == MEMCACHED_SUCCESS);
4778
4779       memcached_result_st *results= memcached_result_create(memc_clone, &result_obj);
4780       test_true(results);
4781
4782       int hits= 0;
4783       while ((results= memcached_fetch_result(memc_clone, &result_obj, &rc)) != NULL)
4784       {
4785         ++hits;
4786       }
4787       test_true(hits == 4);
4788       memcached_result_free(&result_obj);
4789     }
4790   }
4791   memcached_free(memc_clone);
4792
4793   return TEST_SUCCESS;
4794 }
4795
4796 #if 0
4797 static test_return_t hash_sanity_test (memcached_st *memc)
4798 {
4799   (void)memc;
4800
4801   assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
4802   assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
4803   assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
4804   assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
4805   assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
4806   assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
4807   assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
4808 #ifdef HAVE_HSIEH_HASH
4809   assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
4810 #endif
4811   assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
4812   assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
4813   assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
4814
4815   return TEST_SUCCESS;
4816 }
4817 #endif
4818
4819 static test_return_t hsieh_avaibility_test (memcached_st *memc)
4820 {
4821   memcached_return_t expected_rc= MEMCACHED_FAILURE;
4822 #ifdef HAVE_HSIEH_HASH
4823   expected_rc= MEMCACHED_SUCCESS;
4824 #endif
4825   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4826                                                 (uint64_t)MEMCACHED_HASH_HSIEH);
4827   test_true(rc == expected_rc);
4828
4829   return TEST_SUCCESS;
4830 }
4831
4832 static test_return_t one_at_a_time_run (memcached_st *memc __attribute__((unused)))
4833 {
4834   uint32_t x;
4835   const char **ptr;
4836
4837   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4838   {
4839     uint32_t hash_val;
4840
4841     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
4842     test_true(one_at_a_time_values[x] == hash_val);
4843   }
4844
4845   return TEST_SUCCESS;
4846 }
4847
4848 static test_return_t md5_run (memcached_st *memc __attribute__((unused)))
4849 {
4850   uint32_t x;
4851   const char **ptr;
4852
4853   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4854   {
4855     uint32_t hash_val;
4856
4857     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4858     test_true(md5_values[x] == hash_val);
4859   }
4860
4861   return TEST_SUCCESS;
4862 }
4863
4864 static test_return_t crc_run (memcached_st *memc __attribute__((unused)))
4865 {
4866   uint32_t x;
4867   const char **ptr;
4868
4869   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4870   {
4871     uint32_t hash_val;
4872
4873     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4874     test_true(crc_values[x] == hash_val);
4875   }
4876
4877   return TEST_SUCCESS;
4878 }
4879
4880 static test_return_t fnv1_64_run (memcached_st *memc __attribute__((unused)))
4881 {
4882   uint32_t x;
4883   const char **ptr;
4884
4885   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4886   {
4887     uint32_t hash_val;
4888
4889     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4890     test_true(fnv1_64_values[x] == hash_val);
4891   }
4892
4893   return TEST_SUCCESS;
4894 }
4895
4896 static test_return_t fnv1a_64_run (memcached_st *memc __attribute__((unused)))
4897 {
4898   uint32_t x;
4899   const char **ptr;
4900
4901   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4902   {
4903     uint32_t hash_val;
4904
4905     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4906     test_true(fnv1a_64_values[x] == hash_val);
4907   }
4908
4909   return TEST_SUCCESS;
4910 }
4911
4912 static test_return_t fnv1_32_run (memcached_st *memc __attribute__((unused)))
4913 {
4914   uint32_t x;
4915   const char **ptr;
4916
4917
4918   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4919   {
4920     uint32_t hash_val;
4921
4922     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4923     test_true(fnv1_32_values[x] == hash_val);
4924   }
4925
4926   return TEST_SUCCESS;
4927 }
4928
4929 static test_return_t fnv1a_32_run (memcached_st *memc __attribute__((unused)))
4930 {
4931   uint32_t x;
4932   const char **ptr;
4933
4934   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4935   {
4936     uint32_t hash_val;
4937
4938     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4939     test_true(fnv1a_32_values[x] == hash_val);
4940   }
4941
4942   return TEST_SUCCESS;
4943 }
4944
4945 static test_return_t hsieh_run (memcached_st *memc __attribute__((unused)))
4946 {
4947   uint32_t x;
4948   const char **ptr;
4949
4950   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4951   {
4952     uint32_t hash_val;
4953
4954     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4955     test_true(hsieh_values[x] == hash_val);
4956   }
4957
4958   return TEST_SUCCESS;
4959 }
4960
4961 static test_return_t murmur_run (memcached_st *memc __attribute__((unused)))
4962 {
4963 #ifdef WORDS_BIGENDIAN
4964   return TEST_SKIPPED;
4965 #else
4966   uint32_t x;
4967   const char **ptr;
4968
4969   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4970   {
4971     uint32_t hash_val;
4972
4973     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
4974     test_true(murmur_values[x] == hash_val);
4975   }
4976
4977   return TEST_SUCCESS;
4978 #endif
4979 }
4980
4981 static test_return_t jenkins_run (memcached_st *memc __attribute__((unused)))
4982 {
4983   uint32_t x;
4984   const char **ptr;
4985
4986
4987   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4988   {
4989     uint32_t hash_val;
4990
4991     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4992     test_true(jenkins_values[x] == hash_val);
4993   }
4994
4995   return TEST_SUCCESS;
4996 }
4997
4998 static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
4999 {
5000   (void)context;
5001   return libhashkit_md5(string, string_length);
5002 }
5003
5004 static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
5005 {
5006   (void)context;
5007   return libhashkit_crc32(string, string_length);
5008 }
5009
5010 static test_return_t memcached_get_hashkit_test (memcached_st *memc)
5011 {
5012   uint32_t x;
5013   const char **ptr;
5014   const hashkit_st *kit;
5015   hashkit_st new_kit;
5016   hashkit_return_t hash_rc;
5017
5018   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};
5019   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};
5020
5021   kit= memcached_get_hashkit(memc);
5022
5023   hashkit_clone(&new_kit, kit);
5024   hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
5025   test_true(hash_rc == HASHKIT_SUCCESS);
5026
5027   memcached_set_hashkit(memc, &new_kit);
5028
5029   /*
5030     Verify Setting the hash.
5031   */
5032   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5033   {
5034     uint32_t hash_val;
5035
5036     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
5037     test_true(md5_values[x] == hash_val);
5038   }
5039
5040
5041   /*
5042     Now check memcached_st.
5043   */
5044   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5045   {
5046     uint32_t hash_val;
5047
5048     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
5049     test_true(md5_hosts[x] == hash_val);
5050   }
5051
5052   hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
5053   test_true(hash_rc == HASHKIT_SUCCESS);
5054
5055   memcached_set_hashkit(memc, &new_kit);
5056
5057   /*
5058     Verify Setting the hash.
5059   */
5060   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5061   {
5062     uint32_t hash_val;
5063
5064     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
5065     test_true(crc_values[x] == hash_val);
5066   }
5067
5068   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
5069   {
5070     uint32_t hash_val;
5071
5072     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
5073     test_true(crc_hosts[x] == hash_val);
5074   }
5075
5076   return TEST_SUCCESS;
5077 }
5078
5079 /*
5080   Test case adapted from John Gorman <johngorman2@gmail.com>
5081
5082   We are testing the error condition when we connect to a server via memcached_get()
5083   but find that the server is not available.
5084 */
5085 static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
5086 {
5087   (void)memc;
5088   memcached_st *tl_memc_h;
5089   memcached_server_st *servers;
5090
5091   const char *key= "MemcachedLives";
5092   size_t len;
5093   uint32_t flags;
5094   memcached_return rc;
5095   char *value;
5096
5097   // Create a handle.
5098   tl_memc_h= memcached_create(NULL);
5099   servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5100   memcached_server_push(tl_memc_h, servers);
5101   memcached_server_list_free(servers);
5102
5103   // See if memcached is reachable.
5104   value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
5105
5106   test_false(value);
5107   test_true(len == 0);
5108   test_false(rc == MEMCACHED_SUCCESS);
5109
5110   memcached_free(tl_memc_h);
5111
5112   return TEST_SUCCESS;
5113 }
5114
5115 /*
5116   We connect to a server which exists, but search for a key that does not exist.
5117 */
5118 static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
5119 {
5120   const char *key= "MemcachedKeyNotEXIST";
5121   size_t len;
5122   uint32_t flags;
5123   memcached_return rc;
5124   char *value;
5125
5126   // See if memcached is reachable.
5127   value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
5128
5129   test_false(value);
5130   test_true(len == 0);
5131   test_true(rc == MEMCACHED_NOTFOUND);
5132
5133   return TEST_SUCCESS;
5134 }
5135
5136 /*
5137   Test case adapted from John Gorman <johngorman2@gmail.com>
5138
5139   We are testing the error condition when we connect to a server via memcached_get_by_key()
5140   but find that the server is not available.
5141 */
5142 static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
5143 {
5144   (void)memc;
5145   memcached_st *tl_memc_h;
5146   memcached_server_st *servers;
5147
5148   const char *key= "MemcachedLives";
5149   size_t len;
5150   uint32_t flags;
5151   memcached_return rc;
5152   char *value;
5153
5154   // Create a handle.
5155   tl_memc_h= memcached_create(NULL);
5156   servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
5157   memcached_server_push(tl_memc_h, servers);
5158   memcached_server_list_free(servers);
5159
5160   // See if memcached is reachable.
5161   value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
5162
5163   test_false(value);
5164   test_true(len == 0);
5165   test_false(rc == MEMCACHED_SUCCESS);
5166
5167   memcached_free(tl_memc_h);
5168
5169   return TEST_SUCCESS;
5170 }
5171
5172 /*
5173   We connect to a server which exists, but search for a key that does not exist.
5174 */
5175 static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
5176 {
5177   const char *key= "MemcachedKeyNotEXIST";
5178   size_t len;
5179   uint32_t flags;
5180   memcached_return rc;
5181   char *value;
5182
5183   // See if memcached is reachable.
5184   value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
5185
5186   test_false(value);
5187   test_true(len == 0);
5188   test_true(rc == MEMCACHED_NOTFOUND);
5189
5190   return TEST_SUCCESS;
5191 }
5192
5193
5194 static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
5195 {
5196   memcached_return_t rc;
5197   uint64_t value;
5198   int x;
5199   memcached_server_st *server_pool;
5200   memcached_st *memc;
5201
5202   (void)trash;
5203
5204   memc= memcached_create(NULL);
5205   test_true(memc);
5206
5207   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
5208   test_true(rc == MEMCACHED_SUCCESS);
5209
5210   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
5211   test_true(value == 1);
5212
5213   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
5214   test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
5215
5216
5217   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");
5218   memcached_server_push(memc, server_pool);
5219
5220   /* verify that the server list was parsed okay. */
5221   test_true(memcached_server_count(memc) == 8);
5222   test_strcmp(server_pool[0].hostname, "10.0.1.1");
5223   test_true(server_pool[0].port == 11211);
5224   test_true(server_pool[0].weight == 600);
5225   test_strcmp(server_pool[2].hostname, "10.0.1.3");
5226   test_true(server_pool[2].port == 11211);
5227   test_true(server_pool[2].weight == 200);
5228   test_strcmp(server_pool[7].hostname, "10.0.1.8");
5229   test_true(server_pool[7].port == 11211);
5230   test_true(server_pool[7].weight == 100);
5231
5232   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5233    * us test the boundary wraparound.
5234    */
5235   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
5236
5237   /* verify the standard ketama set. */
5238   for (x= 0; x < 99; x++)
5239   {
5240     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
5241     memcached_server_instance_st instance=
5242       memcached_server_instance_by_position(memc, server_idx);
5243     const char *hostname = memcached_server_name(instance);
5244
5245     test_strcmp(hostname, ketama_test_cases[x].server);
5246   }
5247
5248   memcached_server_list_free(server_pool);
5249   memcached_free(memc);
5250
5251   return TEST_SUCCESS;
5252 }
5253
5254 static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
5255 {
5256   memcached_return_t rc;
5257   uint64_t value;
5258   int x;
5259   memcached_server_st *server_pool;
5260   memcached_st *memc;
5261
5262   (void)trash;
5263
5264   memc= memcached_create(NULL);
5265   test_true(memc);
5266
5267   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
5268   test_true(rc == MEMCACHED_SUCCESS);
5269
5270   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
5271   test_true(value == 1);
5272
5273   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
5274   test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
5275
5276   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");
5277   memcached_server_push(memc, server_pool);
5278
5279   /* verify that the server list was parsed okay. */
5280   test_true(memcached_server_count(memc) == 8);
5281   test_strcmp(server_pool[0].hostname, "10.0.1.1");
5282   test_true(server_pool[0].port == 11211);
5283   test_true(server_pool[0].weight == 600);
5284   test_strcmp(server_pool[2].hostname, "10.0.1.3");
5285   test_true(server_pool[2].port == 11211);
5286   test_true(server_pool[2].weight == 200);
5287   test_strcmp(server_pool[7].hostname, "10.0.1.8");
5288   test_true(server_pool[7].port == 11211);
5289   test_true(server_pool[7].weight == 100);
5290
5291   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5292    * us test the boundary wraparound.
5293    */
5294   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->continuum[0].index);
5295
5296   /* verify the standard ketama set. */
5297   for (x= 0; x < 99; x++)
5298   {
5299     uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
5300
5301     memcached_server_instance_st instance=
5302       memcached_server_instance_by_position(memc, server_idx);
5303
5304     const char *hostname= memcached_server_name(instance);
5305
5306     test_strcmp(hostname, ketama_test_cases_spy[x].server);
5307   }
5308
5309   memcached_server_list_free(server_pool);
5310   memcached_free(memc);
5311
5312   return TEST_SUCCESS;
5313 }
5314
5315 static test_return_t regression_bug_434484(memcached_st *memc)
5316 {
5317   test_return_t test_rc;
5318   test_rc= pre_binary(memc);
5319
5320   if (test_rc != TEST_SUCCESS)
5321     return test_rc;
5322
5323   memcached_return_t ret;
5324   const char *key= "regression_bug_434484";
5325   size_t keylen= strlen(key);
5326
5327   ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
5328   test_true(ret == MEMCACHED_NOTSTORED);
5329
5330   size_t size= 2048 * 1024;
5331   void *data= calloc(1, size);
5332   test_true(data != NULL);
5333   ret= memcached_set(memc, key, keylen, data, size, 0, 0);
5334   test_true(ret == MEMCACHED_E2BIG);
5335   free(data);
5336
5337   return TEST_SUCCESS;
5338 }
5339
5340 static test_return_t regression_bug_434843(memcached_st *memc)
5341 {
5342   test_return_t test_rc;
5343   test_rc= pre_binary(memc);
5344
5345   if (test_rc != TEST_SUCCESS)
5346     return test_rc;
5347
5348   memcached_return_t rc;
5349   size_t counter= 0;
5350   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
5351
5352   /*
5353    * I only want to hit only _one_ server so I know the number of requests I'm
5354    * sending in the pipleine to the server. Let's try to do a multiget of
5355    * 1024 (that should satisfy most users don't you think?). Future versions
5356    * will include a mget_execute function call if you need a higher number.
5357    */
5358   uint32_t number_of_hosts= memcached_server_count(memc);
5359   memc->number_of_hosts= 1;
5360   const size_t max_keys= 1024;
5361   char **keys= calloc(max_keys, sizeof(char*));
5362   size_t *key_length=calloc(max_keys, sizeof(size_t));
5363
5364   for (size_t x= 0; x < max_keys; ++x)
5365   {
5366      char k[251];
5367
5368      key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5369      keys[x]= strdup(k);
5370      test_true(keys[x] != NULL);
5371   }
5372
5373   /*
5374    * Run two times.. the first time we should have 100% cache miss,
5375    * and the second time we should have 100% cache hits
5376    */
5377   for (size_t y= 0; y < 2; y++)
5378   {
5379     rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
5380     test_true(rc == MEMCACHED_SUCCESS);
5381     rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5382
5383     if (y == 0)
5384     {
5385       /* The first iteration should give me a 100% cache miss. verify that*/
5386       char blob[1024]= { 0 };
5387
5388       test_true(counter == 0);
5389
5390       for (size_t x= 0; x < max_keys; ++x)
5391       {
5392         rc= memcached_add(memc, keys[x], key_length[x],
5393                           blob, sizeof(blob), 0, 0);
5394         test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5395       }
5396     }
5397     else
5398     {
5399       /* Verify that we received all of the key/value pairs */
5400        test_true(counter == max_keys);
5401     }
5402   }
5403
5404   /* Release allocated resources */
5405   for (size_t x= 0; x < max_keys; ++x)
5406   {
5407     free(keys[x]);
5408   }
5409   free(keys);
5410   free(key_length);
5411
5412   memc->number_of_hosts= number_of_hosts;
5413
5414   return TEST_SUCCESS;
5415 }
5416
5417 static test_return_t regression_bug_434843_buffered(memcached_st *memc)
5418 {
5419   memcached_return_t rc;
5420   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
5421   test_true(rc == MEMCACHED_SUCCESS);
5422
5423   return regression_bug_434843(memc);
5424 }
5425
5426 static test_return_t regression_bug_421108(memcached_st *memc)
5427 {
5428   memcached_return_t rc;
5429   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
5430   test_true(rc == MEMCACHED_SUCCESS);
5431
5432   char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
5433   test_true(rc == MEMCACHED_SUCCESS);
5434   test_true(bytes != NULL);
5435   char *bytes_read= memcached_stat_get_value(memc, memc_stat,
5436                                              "bytes_read", &rc);
5437   test_true(rc == MEMCACHED_SUCCESS);
5438   test_true(bytes_read != NULL);
5439
5440   char *bytes_written= memcached_stat_get_value(memc, memc_stat,
5441                                                 "bytes_written", &rc);
5442   test_true(rc == MEMCACHED_SUCCESS);
5443   test_true(bytes_written != NULL);
5444
5445   test_true(strcmp(bytes, bytes_read) != 0);
5446   test_true(strcmp(bytes, bytes_written) != 0);
5447
5448   /* Release allocated resources */
5449   free(bytes);
5450   free(bytes_read);
5451   free(bytes_written);
5452   memcached_stat_free(NULL, memc_stat);
5453
5454   return TEST_SUCCESS;
5455 }
5456
5457 /*
5458  * The test case isn't obvious so I should probably document why
5459  * it works the way it does. Bug 442914 was caused by a bug
5460  * in the logic in memcached_purge (it did not handle the case
5461  * where the number of bytes sent was equal to the watermark).
5462  * In this test case, create messages so that we hit that case
5463  * and then disable noreply mode and issue a new command to
5464  * verify that it isn't stuck. If we change the format for the
5465  * delete command or the watermarks, we need to update this
5466  * test....
5467  */
5468 static test_return_t regression_bug_442914(memcached_st *memc)
5469 {
5470   memcached_return_t rc;
5471   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
5472   test_true(rc == MEMCACHED_SUCCESS);
5473   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5474
5475   uint32_t number_of_hosts= memcached_server_count(memc);
5476   memc->number_of_hosts= 1;
5477
5478   char k[250];
5479   size_t len;
5480
5481   for (uint32_t x= 0; x < 250; ++x)
5482   {
5483      len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
5484      rc= memcached_delete(memc, k, len, 0);
5485      test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5486   }
5487
5488   (void)snprintf(k, sizeof(k), "%037u", 251U);
5489   len= strlen(k);
5490
5491   rc= memcached_delete(memc, k, len, 0);
5492   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5493
5494   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
5495   test_true(rc == MEMCACHED_SUCCESS);
5496   rc= memcached_delete(memc, k, len, 0);
5497   test_true(rc == MEMCACHED_NOTFOUND);
5498
5499   memc->number_of_hosts= number_of_hosts;
5500
5501   return TEST_SUCCESS;
5502 }
5503
5504 static test_return_t regression_bug_447342(memcached_st *memc)
5505 {
5506   memcached_server_instance_st instance_one;
5507   memcached_server_instance_st instance_two;
5508
5509   if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
5510     return TEST_SKIPPED;
5511
5512   memcached_return_t rc;
5513
5514   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
5515   test_true(rc == MEMCACHED_SUCCESS);
5516
5517   const size_t max_keys= 100;
5518   char **keys= calloc(max_keys, sizeof(char*));
5519   size_t *key_length= calloc(max_keys, sizeof(size_t));
5520
5521   for (size_t x= 0; x < max_keys; ++x)
5522   {
5523     char k[251];
5524
5525     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5526     keys[x]= strdup(k);
5527     test_true(keys[x] != NULL);
5528     rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
5529     test_true(rc == MEMCACHED_SUCCESS);
5530   }
5531
5532   /*
5533   ** We are using the quiet commands to store the replicas, so we need
5534   ** to ensure that all of them are processed before we can continue.
5535   ** In the test we go directly from storing the object to trying to
5536   ** receive the object from all of the different servers, so we
5537   ** could end up in a race condition (the memcached server hasn't yet
5538   ** processed the quiet command from the replication set when it process
5539   ** the request from the other client (created by the clone)). As a
5540   ** workaround for that we call memcached_quit to send the quit command
5541   ** to the server and wait for the response ;-) If you use the test code
5542   ** as an example for your own code, please note that you shouldn't need
5543   ** to do this ;-)
5544   */
5545   memcached_quit(memc);
5546
5547   /* Verify that all messages are stored, and we didn't stuff too much
5548    * into the servers
5549    */
5550   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5551   test_true(rc == MEMCACHED_SUCCESS);
5552
5553   size_t counter= 0;
5554   memcached_execute_fn callbacks[1]= { [0]= &callback_counter };
5555   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5556   /* Verify that we received all of the key/value pairs */
5557   test_true(counter == max_keys);
5558
5559   memcached_quit(memc);
5560   /*
5561    * Don't do the following in your code. I am abusing the internal details
5562    * within the library, and this is not a supported interface.
5563    * This is to verify correct behavior in the library. Fake that two servers
5564    * are dead..
5565    */
5566   instance_one= memcached_server_instance_by_position(memc, 0);
5567   instance_two= memcached_server_instance_by_position(memc, 2);
5568   in_port_t port0= instance_one->port;
5569   in_port_t port2= instance_two->port;
5570
5571   ((memcached_server_write_instance_st)instance_one)->port= 0;
5572   ((memcached_server_write_instance_st)instance_two)->port= 0;
5573
5574   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5575   test_true(rc == MEMCACHED_SUCCESS);
5576
5577   counter= 0;
5578   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5579   test_true(counter == (unsigned int)max_keys);
5580
5581   /* restore the memc handle */
5582   ((memcached_server_write_instance_st)instance_one)->port= port0;
5583   ((memcached_server_write_instance_st)instance_two)->port= port2;
5584
5585   memcached_quit(memc);
5586
5587   /* Remove half of the objects */
5588   for (size_t x= 0; x < max_keys; ++x)
5589   {
5590     if (x & 1)
5591     {
5592       rc= memcached_delete(memc, keys[x], key_length[x], 0);
5593       test_true(rc == MEMCACHED_SUCCESS);
5594     }
5595   }
5596
5597   memcached_quit(memc);
5598   ((memcached_server_write_instance_st)instance_one)->port= 0;
5599   ((memcached_server_write_instance_st)instance_two)->port= 0;
5600
5601   /* now retry the command, this time we should have cache misses */
5602   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5603   test_true(rc == MEMCACHED_SUCCESS);
5604
5605   counter= 0;
5606   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5607   test_true(counter == (unsigned int)(max_keys >> 1));
5608
5609   /* Release allocated resources */
5610   for (size_t x= 0; x < max_keys; ++x)
5611   {
5612     free(keys[x]);
5613   }
5614   free(keys);
5615   free(key_length);
5616
5617   /* restore the memc handle */
5618   ((memcached_server_write_instance_st)instance_one)->port= port0;
5619   ((memcached_server_write_instance_st)instance_two)->port= port2;
5620
5621   return TEST_SUCCESS;
5622 }
5623
5624 static test_return_t regression_bug_463297(memcached_st *memc)
5625 {
5626   memcached_st *memc_clone= memcached_clone(NULL, memc);
5627   test_true(memc_clone != NULL);
5628   test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
5629
5630   memcached_server_instance_st instance=
5631     memcached_server_instance_by_position(memc_clone, 0);
5632
5633   if (instance->major_version > 1 ||
5634       (instance->major_version == 1 &&
5635        instance->minor_version > 2))
5636   {
5637     /* Binary protocol doesn't support deferred delete */
5638     memcached_st *bin_clone= memcached_clone(NULL, memc);
5639     test_true(bin_clone != NULL);
5640     test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
5641     test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5642     memcached_free(bin_clone);
5643
5644     memcached_quit(memc_clone);
5645
5646     /* If we know the server version, deferred delete should fail
5647      * with invalid arguments */
5648     test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5649
5650     /* If we don't know the server version, we should get a protocol error */
5651     memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
5652
5653     /* but there is a bug in some of the memcached servers (1.4) that treats
5654      * the counter as noreply so it doesn't send the proper error message
5655      */
5656     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5657
5658     /* And buffered mode should be disabled and we should get protocol error */
5659     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
5660     rc= memcached_delete(memc, "foo", 3, 1);
5661     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5662
5663     /* Same goes for noreply... */
5664     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
5665     rc= memcached_delete(memc, "foo", 3, 1);
5666     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5667
5668     /* but a normal request should go through (and be buffered) */
5669     test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
5670     test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
5671
5672     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
5673     /* unbuffered noreply should be success */
5674     test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
5675     /* unbuffered with reply should be not found... */
5676     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
5677     test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
5678   }
5679
5680   memcached_free(memc_clone);
5681   return TEST_SUCCESS;
5682 }
5683
5684
5685 /* Test memcached_server_get_last_disconnect
5686  * For a working server set, shall be NULL
5687  * For a set of non existing server, shall not be NULL
5688  */
5689 static test_return_t test_get_last_disconnect(memcached_st *memc)
5690 {
5691   memcached_return_t rc;
5692   memcached_server_instance_st disconnected_server;
5693
5694   /* With the working set of server */
5695   const char *key= "marmotte";
5696   const char *value= "milka";
5697
5698   memcached_reset_last_disconnected_server(memc);
5699   rc= memcached_set(memc, key, strlen(key),
5700                     value, strlen(value),
5701                     (time_t)0, (uint32_t)0);
5702   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5703
5704   disconnected_server = memcached_server_get_last_disconnect(memc);
5705   test_true(disconnected_server == NULL);
5706
5707   /* With a non existing server */
5708   memcached_st *mine;
5709   memcached_server_st *servers;
5710
5711   const char *server_list= "localhost:9";
5712
5713   servers= memcached_servers_parse(server_list);
5714   test_true(servers);
5715   mine= memcached_create(NULL);
5716   rc= memcached_server_push(mine, servers);
5717   test_true(rc == MEMCACHED_SUCCESS);
5718   memcached_server_list_free(servers);
5719   test_true(mine);
5720
5721   rc= memcached_set(mine, key, strlen(key),
5722                     value, strlen(value),
5723                     (time_t)0, (uint32_t)0);
5724   test_true(rc != MEMCACHED_SUCCESS);
5725
5726   disconnected_server= memcached_server_get_last_disconnect(mine);
5727   if (disconnected_server == NULL)
5728   {
5729     fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
5730     abort();
5731   }
5732   test_true(disconnected_server != NULL);
5733   test_true(memcached_server_port(disconnected_server)== 9);
5734   test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
5735
5736   memcached_quit(mine);
5737   memcached_free(mine);
5738
5739   return TEST_SUCCESS;
5740 }
5741
5742 static test_return_t test_verbosity(memcached_st *memc)
5743 {
5744   memcached_verbosity(memc, 3);
5745
5746   return TEST_SUCCESS;
5747 }
5748
5749 static test_return_t test_server_failure(memcached_st *memc)
5750 {
5751   memcached_st *local_memc;
5752   memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
5753
5754   local_memc= memcached_create(NULL);
5755
5756   memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
5757   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
5758
5759   uint32_t server_count= memcached_server_count(local_memc);
5760
5761   test_true(server_count == 1);
5762
5763   // Disable the server
5764   instance= memcached_server_instance_by_position(local_memc, 0);
5765   ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
5766
5767   memcached_return_t rc;
5768   rc= memcached_set(local_memc, "foo", strlen("foo"),
5769                     NULL, 0,
5770                     (time_t)0, (uint32_t)0);
5771   test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
5772
5773   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5774   rc= memcached_set(local_memc, "foo", strlen("foo"),
5775                     NULL, 0,
5776                     (time_t)0, (uint32_t)0);
5777   test_true(rc == MEMCACHED_SUCCESS);
5778
5779
5780   memcached_free(local_memc);
5781
5782   return TEST_SUCCESS;
5783 }
5784
5785 static test_return_t test_cull_servers(memcached_st *memc)
5786 {
5787   uint32_t count = memcached_server_count(memc);
5788
5789   // Do not do this in your code, it is not supported.
5790   memc->servers[1].state.is_dead= true;
5791   memc->state.is_time_for_rebuild= true;
5792
5793   uint32_t new_count= memcached_server_count(memc);
5794   test_true(count == new_count);
5795
5796 #if 0
5797   test_true(count == new_count + 1 );
5798 #endif
5799
5800   return TEST_SUCCESS;
5801 }
5802
5803
5804 static memcached_return_t stat_printer(memcached_server_instance_st server,
5805                                        const char *key, size_t key_length,
5806                                        const char *value, size_t value_length,
5807                                        void *context)
5808 {
5809   (void)server;
5810   (void)context;
5811   (void)key;
5812   (void)key_length;
5813   (void)value;
5814   (void)value_length;
5815
5816   return MEMCACHED_SUCCESS;
5817 }
5818
5819 static test_return_t memcached_stat_execute_test(memcached_st *memc)
5820 {
5821   memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
5822   test_true(rc == MEMCACHED_SUCCESS);
5823
5824   rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
5825   test_true(rc == MEMCACHED_SUCCESS);
5826
5827   rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
5828   test_true(rc == MEMCACHED_SUCCESS);
5829
5830   rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
5831   test_true(rc == MEMCACHED_SUCCESS);
5832
5833   return TEST_SUCCESS;
5834 }
5835
5836 /*
5837  * This test ensures that the failure counter isn't incremented during
5838  * normal termination of the memcached instance.
5839  */
5840 static test_return_t wrong_failure_counter_test(memcached_st *memc)
5841 {
5842   memcached_return_t rc;
5843   memcached_server_instance_st instance;
5844
5845   /* Set value to force connection to the server */
5846   const char *key= "marmotte";
5847   const char *value= "milka";
5848
5849   /*
5850    * Please note that I'm abusing the internal structures in libmemcached
5851    * in a non-portable way and you shouldn't be doing this. I'm only
5852    * doing this in order to verify that the library works the way it should
5853    */
5854   uint32_t number_of_hosts= memcached_server_count(memc);
5855   memc->number_of_hosts= 1;
5856
5857   /* Ensure that we are connected to the server by setting a value */
5858   rc= memcached_set(memc, key, strlen(key),
5859                     value, strlen(value),
5860                     (time_t)0, (uint32_t)0);
5861   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5862
5863
5864   instance= memcached_server_instance_by_position(memc, 0);
5865   /* The test is to see that the memcached_quit doesn't increase the
5866    * the server failure conter, so let's ensure that it is zero
5867    * before sending quit
5868    */
5869   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5870
5871   memcached_quit(memc);
5872
5873   /* Verify that it memcached_quit didn't increment the failure counter
5874    * Please note that this isn't bullet proof, because an error could
5875    * occur...
5876    */
5877   test_true(instance->server_failure_counter == 0);
5878
5879   /* restore the instance */
5880   memc->number_of_hosts= number_of_hosts;
5881
5882   return TEST_SUCCESS;
5883 }
5884
5885
5886
5887
5888 /*
5889  * Test that ensures mget_execute does not end into recursive calls that finally fails
5890  */
5891 static test_return_t regression_bug_490486(memcached_st *memc)
5892 {
5893   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
5894   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
5895   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
5896   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
5897   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
5898
5899 #ifdef __APPLE__
5900   return TEST_SKIPPED; // My MAC can't handle this test
5901 #endif
5902
5903   /*
5904    * I only want to hit _one_ server so I know the number of requests I'm
5905    * sending in the pipeline.
5906    */
5907   uint32_t number_of_hosts= memc->number_of_hosts;
5908   memc->number_of_hosts= 1;
5909   size_t max_keys= 20480;
5910
5911
5912   char **keys= calloc(max_keys, sizeof(char*));
5913   size_t *key_length=calloc(max_keys, sizeof(size_t));
5914
5915   /* First add all of the items.. */
5916   bool slept= false;
5917   char blob[1024]= { 0 };
5918   memcached_return rc;
5919   for (size_t x= 0; x < max_keys; ++x)
5920   {
5921     char k[251];
5922     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5923     keys[x]= strdup(k);
5924     assert(keys[x] != NULL);
5925     rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
5926 #ifdef __APPLE__
5927     if (rc == MEMCACHED_SERVER_MARKED_DEAD)
5928     {
5929       break; // We are out of business
5930     }
5931 #endif
5932     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX
5933
5934     if (rc == MEMCACHED_TIMEOUT && slept == false)
5935     {
5936       x++;
5937       sleep(1);// We will try to sleep
5938       slept= true;
5939     }
5940     else if (rc == MEMCACHED_TIMEOUT && slept == true)
5941     {
5942       // We failed to send everything.
5943       break;
5944     }
5945   }
5946
5947   if (rc != MEMCACHED_SERVER_MARKED_DEAD)
5948   {
5949
5950     /* Try to get all of them with a large multiget */
5951     size_t counter= 0;
5952     memcached_execute_function callbacks[1]= { [0]= &callback_counter };
5953     rc= memcached_mget_execute(memc, (const char**)keys, key_length,
5954                                (size_t)max_keys, callbacks, &counter, 1);
5955
5956     assert(rc == MEMCACHED_SUCCESS);
5957     char* the_value= NULL;
5958     char the_key[MEMCACHED_MAX_KEY];
5959     size_t the_key_length;
5960     size_t the_value_length;
5961     uint32_t the_flags;
5962
5963     do {
5964       the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
5965
5966       if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
5967       {
5968         ++counter;
5969         free(the_value);
5970       }
5971
5972     } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
5973
5974
5975     assert(rc == MEMCACHED_END);
5976
5977     /* Verify that we got all of the items */
5978     assert(counter == max_keys);
5979   }
5980
5981   /* Release all allocated resources */
5982   for (size_t x= 0; x < max_keys; ++x)
5983   {
5984     free(keys[x]);
5985   }
5986   free(keys);
5987   free(key_length);
5988
5989   memc->number_of_hosts= number_of_hosts;
5990
5991   return TEST_SUCCESS;
5992 }
5993
5994 static test_return_t regression_bug_583031(memcached_st *unused)
5995 {
5996   (void)unused;
5997
5998     memcached_st *memc= memcached_create(NULL);
5999     assert(memc);
6000     memcached_server_add(memc, "10.2.3.4", 11211);
6001
6002     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
6003     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
6004     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
6005     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
6006     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
6007     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
6008
6009     memcached_return_t rc;
6010     size_t length;
6011     uint32_t flags;
6012
6013     (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
6014
6015     test_true_got(rc == MEMCACHED_TIMEOUT, memcached_strerror(NULL, rc));
6016
6017     memcached_free(memc);
6018
6019     return TEST_SUCCESS;
6020 }
6021
6022 static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
6023 {
6024   fprintf(stderr, "Iteration #%u: ", it);
6025
6026   if(error == MEMCACHED_ERRNO)
6027   {
6028     fprintf(stderr, "system error %d from %s: %s\n",
6029             errno, what, strerror(errno));
6030   }
6031   else
6032   {
6033     fprintf(stderr, "error %d from %s: %s\n", error, what,
6034             memcached_strerror(mc, error));
6035   }
6036 }
6037
6038 #define TEST_CONSTANT_CREATION 200
6039
6040 static test_return_t regression_bug_(memcached_st *memc)
6041 {
6042   const char *remote_server;
6043   (void)memc;
6044
6045   if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
6046   {
6047     return TEST_SKIPPED;
6048   }
6049
6050   for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
6051   {
6052     memcached_st* mc= memcached_create(NULL);
6053     memcached_return rc;
6054
6055     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
6056     if (rc != MEMCACHED_SUCCESS)
6057     {
6058       memcached_die(mc, rc, "memcached_behavior_set", x);
6059     }
6060
6061     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
6062     if (rc != MEMCACHED_SUCCESS)
6063     {
6064       memcached_die(mc, rc, "memcached_behavior_set", x);
6065     }
6066
6067     rc= memcached_server_add(mc, remote_server, 0);
6068     if (rc != MEMCACHED_SUCCESS)
6069     {
6070       memcached_die(mc, rc, "memcached_server_add", x);
6071     }
6072
6073     const char *set_key= "akey";
6074     const size_t set_key_len= strlen(set_key);
6075     const char *set_value= "a value";
6076     const size_t set_value_len= strlen(set_value);
6077
6078     if (rc == MEMCACHED_SUCCESS)
6079     {
6080       if (x > 0)
6081       {
6082         size_t get_value_len;
6083         char *get_value;
6084         uint32_t get_value_flags;
6085
6086         get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
6087                                  &get_value_flags, &rc);
6088         if (rc != MEMCACHED_SUCCESS)
6089         {
6090           memcached_die(mc, rc, "memcached_get", x);
6091         }
6092         else
6093         {
6094
6095           if (x != 0 &&
6096               (get_value_len != set_value_len
6097                || 0!=strncmp(get_value, set_value, get_value_len)))
6098           {
6099             fprintf(stderr, "Values don't match?\n");
6100             rc= MEMCACHED_FAILURE;
6101           }
6102           free(get_value);
6103         }
6104       }
6105
6106       rc= memcached_set(mc,
6107                         set_key, set_key_len,
6108                         set_value, set_value_len,
6109                         0, /* time */
6110                         0  /* flags */
6111                        );
6112       if (rc != MEMCACHED_SUCCESS)
6113       {
6114         memcached_die(mc, rc, "memcached_set", x);
6115       }
6116     }
6117
6118     memcached_quit(mc);
6119     memcached_free(mc);
6120
6121     if (rc != MEMCACHED_SUCCESS)
6122     {
6123       break;
6124     }
6125   }
6126
6127   return TEST_SUCCESS;
6128 }
6129
6130 /*
6131  * Test that the sasl authentication works. We cannot use the default
6132  * pool of servers, because that would require that all servers we want
6133  * to test supports SASL authentication, and that they use the default
6134  * creds.
6135  */
6136 static test_return_t sasl_auth_test(memcached_st *memc)
6137 {
6138 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
6139   memcached_return_t rc;
6140
6141   rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6142   test_true(rc == MEMCACHED_SUCCESS);
6143   test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_SUCCESS);
6144   test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_SUCCESS);
6145   test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_FAILURE);
6146   test_true((rc= memcached_destroy_sasl_auth_data(NULL)) == MEMCACHED_FAILURE);
6147   memcached_quit(memc);
6148
6149   rc= memcached_set_sasl_auth_data(memc,
6150                                    getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
6151                                    getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
6152   test_true(rc == MEMCACHED_SUCCESS);
6153
6154   rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
6155   test_true(rc == MEMCACHED_AUTH_FAILURE);
6156   test_true(memcached_destroy_sasl_auth_data(memc) == MEMCACHED_SUCCESS);
6157
6158   memcached_quit(memc);
6159   return TEST_SUCCESS;
6160 #else
6161   (void)memc;
6162   return TEST_FAILURE;
6163 #endif
6164 }
6165
6166 /* Clean the server before beginning testing */
6167 test_st tests[] ={
6168   {"util_version", 1, (test_callback_fn)util_version_test },
6169   {"flush", 0, (test_callback_fn)flush_test },
6170   {"init", 0, (test_callback_fn)init_test },
6171   {"allocation", 0, (test_callback_fn)allocation_test },
6172   {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
6173   {"server_unsort", 0, (test_callback_fn)server_unsort_test},
6174   {"server_sort", 0, (test_callback_fn)server_sort_test},
6175   {"server_sort2", 0, (test_callback_fn)server_sort2_test},
6176   {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
6177   {"clone_test", 0, (test_callback_fn)clone_test },
6178   {"connection_test", 0, (test_callback_fn)connection_test},
6179   {"callback_test", 0, (test_callback_fn)callback_test},
6180   {"userdata_test", 0, (test_callback_fn)userdata_test},
6181   {"error", 0, (test_callback_fn)error_test },
6182   {"set", 0, (test_callback_fn)set_test },
6183   {"set2", 0, (test_callback_fn)set_test2 },
6184   {"set3", 0, (test_callback_fn)set_test3 },
6185   {"dump", 1, (test_callback_fn)dump_test},
6186   {"add", 1, (test_callback_fn)add_test },
6187   {"replace", 1, (test_callback_fn)replace_test },
6188   {"delete", 1, (test_callback_fn)delete_test },
6189   {"get", 1, (test_callback_fn)get_test },
6190   {"get2", 0, (test_callback_fn)get_test2 },
6191   {"get3", 0, (test_callback_fn)get_test3 },
6192   {"get4", 0, (test_callback_fn)get_test4 },
6193   {"partial mget", 0, (test_callback_fn)get_test5 },
6194   {"stats_servername", 0, (test_callback_fn)stats_servername_test },
6195   {"increment", 0, (test_callback_fn)increment_test },
6196   {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
6197   {"decrement", 0, (test_callback_fn)decrement_test },
6198   {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
6199   {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
6200   {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
6201   {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
6202   {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
6203   {"quit", 0, (test_callback_fn)quit_test },
6204   {"mget", 1, (test_callback_fn)mget_test },
6205   {"mget_result", 1, (test_callback_fn)mget_result_test },
6206   {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
6207   {"mget_result_function", 1, (test_callback_fn)mget_result_function },
6208   {"mget_execute", 1, (test_callback_fn)mget_execute },
6209   {"mget_end", 0, (test_callback_fn)mget_end },
6210   {"get_stats", 0, (test_callback_fn)get_stats },
6211   {"add_host_test", 0, (test_callback_fn)add_host_test },
6212   {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
6213   {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
6214   {"version_string_test", 0, (test_callback_fn)version_string_test},
6215   {"bad_key", 1, (test_callback_fn)bad_key_test },
6216   {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
6217   {"read_through", 1, (test_callback_fn)read_through },
6218   {"delete_through", 1, (test_callback_fn)delete_through },
6219   {"noreply", 1, (test_callback_fn)noreply_test},
6220   {"analyzer", 1, (test_callback_fn)analyzer_test},
6221 #ifdef HAVE_LIBMEMCACHEDUTIL
6222   {"connectionpool", 1, (test_callback_fn)connection_pool_test },
6223   {"ping", 1, (test_callback_fn)ping_test },
6224 #endif
6225   {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
6226   {"verbosity", 1, (test_callback_fn)test_verbosity},
6227   {"test_server_failure", 1, (test_callback_fn)test_server_failure},
6228   {"cull_servers", 1, (test_callback_fn)test_cull_servers},
6229   {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
6230   {0, 0, 0}
6231 };
6232
6233 test_st behavior_tests[] ={
6234   {"behavior_test", 0, (test_callback_fn)behavior_test},
6235   {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
6236   {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
6237   {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
6238   {0, 0, 0}
6239 };
6240
6241 test_st regression_binary_vs_block[] ={
6242   {"block add", 1, (test_callback_fn)block_add_regression},
6243   {"binary add", 1, (test_callback_fn)binary_add_regression},
6244   {0, 0, 0}
6245 };
6246
6247 test_st async_tests[] ={
6248   {"add", 1, (test_callback_fn)add_wrapper },
6249   {0, 0, 0}
6250 };
6251
6252 test_st string_tests[] ={
6253   {"string static with null", 0, (test_callback_fn)string_static_null },
6254   {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
6255   {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
6256   {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
6257   {"string append", 0, (test_callback_fn)string_alloc_append },
6258   {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
6259   {0, 0, (test_callback_fn)0}
6260 };
6261
6262 test_st result_tests[] ={
6263   {"result static", 0, (test_callback_fn)result_static},
6264   {"result alloc", 0, (test_callback_fn)result_alloc},
6265   {0, 0, (test_callback_fn)0}
6266 };
6267
6268 test_st version_1_2_3[] ={
6269   {"append", 0, (test_callback_fn)append_test },
6270   {"prepend", 0, (test_callback_fn)prepend_test },
6271   {"cas", 0, (test_callback_fn)cas_test },
6272   {"cas2", 0, (test_callback_fn)cas2_test },
6273   {"append_binary", 0, (test_callback_fn)append_binary_test },
6274   {0, 0, (test_callback_fn)0}
6275 };
6276
6277 test_st user_tests[] ={
6278   {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
6279   {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
6280   {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
6281   {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
6282   {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
6283   {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
6284   {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
6285   {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
6286   {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
6287   {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
6288   {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
6289   {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
6290   {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
6291   {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
6292   {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
6293   {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
6294 #if !defined(__sun) && !defined(__OpenBSD__)
6295   /*
6296   ** It seems to be something weird with the character sets..
6297   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6298   ** guess I need to find out how this is supposed to work.. Perhaps I need
6299   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6300   ** so just disable the code for now...).
6301   */
6302   {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
6303 #endif
6304   {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
6305   {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
6306   {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
6307   {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
6308   {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
6309   {0, 0, (test_callback_fn)0}
6310 };
6311
6312 test_st replication_tests[]= {
6313   {"set", 1, (test_callback_fn)replication_set_test },
6314   {"get", 0, (test_callback_fn)replication_get_test },
6315   {"mget", 0, (test_callback_fn)replication_mget_test },
6316   {"delete", 0, (test_callback_fn)replication_delete_test },
6317   {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
6318   {0, 0, (test_callback_fn)0}
6319 };
6320
6321 /*
6322  * The following test suite is used to verify that we don't introduce
6323  * regression bugs. If you want more information about the bug / test,
6324  * you should look in the bug report at
6325  *   http://bugs.launchpad.net/libmemcached
6326  */
6327 test_st regression_tests[]= {
6328   {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
6329   {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
6330   {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
6331   {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
6332   {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
6333   {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
6334   {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
6335   {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
6336   {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
6337   {"lp:?", 1, (test_callback_fn)regression_bug_ },
6338   {0, 0, (test_callback_fn)0}
6339 };
6340
6341 test_st sasl_auth_tests[]= {
6342   {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
6343   {0, 0, (test_callback_fn)0}
6344 };
6345
6346 test_st ketama_compatibility[]= {
6347   {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
6348   {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
6349   {0, 0, (test_callback_fn)0}
6350 };
6351
6352 test_st generate_tests[] ={
6353   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6354   {"generate_data", 1, (test_callback_fn)generate_data },
6355   {"get_read", 0, (test_callback_fn)get_read },
6356   {"delete_generate", 0, (test_callback_fn)delete_generate },
6357   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6358   {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
6359   {"generate_data", 1, (test_callback_fn)generate_data },
6360   {"mget_read", 0, (test_callback_fn)mget_read },
6361   {"mget_read_result", 0, (test_callback_fn)mget_read_result },
6362   {"mget_read_function", 0, (test_callback_fn)mget_read_function },
6363   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6364   {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
6365   {"generate_data", 1, (test_callback_fn)generate_data },
6366   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6367   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6368   {0, 0, (test_callback_fn)0}
6369 };
6370
6371 test_st consistent_tests[] ={
6372   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6373   {"generate_data", 1, (test_callback_fn)generate_data },
6374   {"get_read", 0, (test_callback_fn)get_read_count },
6375   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6376   {0, 0, (test_callback_fn)0}
6377 };
6378
6379 test_st consistent_weighted_tests[] ={
6380   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6381   {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
6382   {"get_read", 0, (test_callback_fn)get_read_count },
6383   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6384   {0, 0, (test_callback_fn)0}
6385 };
6386
6387 test_st hsieh_availability[] ={
6388   {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
6389   {0, 0, (test_callback_fn)0}
6390 };
6391
6392 #if 0
6393 test_st hash_sanity[] ={
6394   {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
6395   {0, 0, (test_callback_fn)0}
6396 };
6397 #endif
6398
6399 test_st ketama_auto_eject_hosts[] ={
6400   {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
6401   {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
6402   {0, 0, (test_callback_fn)0}
6403 };
6404
6405 test_st hash_tests[] ={
6406   {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
6407   {"md5", 0, (test_callback_fn)md5_run },
6408   {"crc", 0, (test_callback_fn)crc_run },
6409   {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
6410   {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
6411   {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
6412   {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
6413   {"hsieh", 0, (test_callback_fn)hsieh_run },
6414   {"murmur", 0, (test_callback_fn)murmur_run },
6415   {"jenkis", 0, (test_callback_fn)jenkins_run },
6416   {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
6417   {0, 0, (test_callback_fn)0}
6418 };
6419
6420 test_st error_conditions[] ={
6421   {"memcached_get_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
6422   {"memcached_get_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
6423   {"memcached_get_by_key_MEMCACHED_ERRNO", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
6424   {"memcached_get_by_key_MEMCACHED_NOTFOUND", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
6425   {0, 0, (test_callback_fn)0}
6426 };
6427
6428 collection_st collection[] ={
6429 #if 0
6430   {"hash_sanity", 0, 0, hash_sanity},
6431 #endif
6432   {"hsieh_availability", 0, 0, hsieh_availability},
6433   {"block", 0, 0, tests},
6434   {"binary", (test_callback_fn)pre_binary, 0, tests},
6435   {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
6436   {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6437   {"settimer", (test_callback_fn)pre_settimer, 0, tests},
6438   {"md5", (test_callback_fn)pre_md5, 0, tests},
6439   {"crc", (test_callback_fn)pre_crc, 0, tests},
6440   {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
6441   {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
6442   {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
6443   {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
6444   {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
6445   {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
6446   {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
6447   {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
6448   {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
6449   {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6450   {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
6451   {"gets", (test_callback_fn)enable_cas, 0, tests},
6452   {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
6453   {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
6454 #ifdef MEMCACHED_ENABLE_DEPRECATED
6455   {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
6456 #endif
6457   {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
6458   {"prefix", (test_callback_fn)set_prefix, 0, tests},
6459   {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
6460   {"sasl", (test_callback_fn)pre_sasl, 0, tests },
6461   {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
6462   {"string", 0, 0, string_tests},
6463   {"result", 0, 0, result_tests},
6464   {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
6465   {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
6466   {"user", 0, 0, user_tests},
6467   {"generate", 0, 0, generate_tests},
6468   {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
6469   {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
6470   {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
6471   {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
6472   {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
6473   {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
6474   {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
6475   // Too slow
6476   {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
6477   {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
6478   {"consistent_not", 0, 0, consistent_tests},
6479   {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
6480   {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
6481   {"ketama_compat", 0, 0, ketama_compatibility},
6482   {"test_hashes", 0, 0, hash_tests},
6483   {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
6484   {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
6485   {"regression", 0, 0, regression_tests},
6486   {"behaviors", 0, 0, behavior_tests},
6487   {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
6488   {"error_conditions", 0, 0, error_conditions},
6489   {0, 0, 0, 0}
6490 };
6491
6492 #define SERVERS_TO_CREATE 5
6493
6494 #include "libmemcached_world.h"
6495
6496 void get_world(world_st *world)
6497 {
6498   world->collections= collection;
6499
6500   world->create= (test_callback_create_fn)world_create;
6501   world->destroy= (test_callback_fn)world_destroy;
6502
6503   world->test.startup= (test_callback_fn)world_test_startup;
6504   world->test.flush= (test_callback_fn)world_flush;
6505   world->test.pre_run= (test_callback_fn)world_pre_run;
6506   world->test.post_run= (test_callback_fn)world_post_run;
6507   world->test.on_error= (test_callback_error_fn)world_on_error;
6508
6509   world->collection.startup= (test_callback_fn)world_container_startup;
6510   world->collection.shutdown= (test_callback_fn)world_container_shutdown;
6511
6512   world->runner= &defualt_libmemcached_runner;
6513 }