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

   1 /*  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
   2  *
   3  *  Libmemcached library
   4  *
   5  *  Copyright (C) 2011 Data Differential, http://datadifferential.com/
   6  *  Copyright (C) 2006-2009 Brian Aker All rights reserved.
   7  *
   8  *  Redistribution and use in source and binary forms, with or without
   9  *  modification, are permitted provided that the following conditions are
  10  *  met:
  11  *
  12  *      * Redistributions of source code must retain the above copyright
  13  *  notice, this list of conditions and the following disclaimer.
  14  *
  15  *      * Redistributions in binary form must reproduce the above
  16  *  copyright notice, this list of conditions and the following disclaimer
  17  *  in the documentation and/or other materials provided with the
  18  *  distribution.
  19  *
  20  *      * The names of its contributors may not be used to endorse or
  21  *  promote products derived from this software without specific prior
  22  *  written permission.
  23  *
  24  *  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  25  *  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  26  *  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  27  *  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  28  *  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  29  *  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  30  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  31  *  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  32  *  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  33  *  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  34  *  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  35  *
  36  */
  37
  38 #include <mem_config.h>
  39 #include <libtest/test.hpp>
  40
  41 #if defined(HAVE_LIBUUID) && HAVE_LIBUUID
  42 # include <uuid/uuid.h>
  43 #endif
  44
  45 /*
  46   Test cases
  47 */
  48
  49 #include <libmemcached-1.0/memcached.h>
  50 #include "libmemcached/is.h"
  51 #include "libmemcached/server_instance.h"
  52
  53 #include <libhashkit-1.0/hashkit.h>
  54
  55 #include <libtest/memcached.hpp>
  56
  57 #include <cerrno>
  58 #include <memory>
  59 #include <pthread.h>
  60 #include <semaphore.h>
  61 #include <signal.h>
  62 #include <sys/stat.h>
  63 #include <sys/time.h>
  64 #include <sys/types.h>
  65 #include <unistd.h>
  66
  67 #include <iostream>
  68
  69 #include <libtest/server.h>
  70
  71 #include "clients/generator.h"
  72
  73 #define SMALL_STRING_LEN 1024
  74
  75 #include <libtest/test.hpp>
  76
  77 using namespace libtest;
  78
  79 #include <libmemcachedutil-1.0/util.h>
  80
  81 #include "tests/hash_results.h"
  82
  83 #include "tests/libmemcached-1.0/callback_counter.h"
  84 #include "tests/libmemcached-1.0/fetch_all_results.h"
  85 #include "tests/libmemcached-1.0/mem_functions.h"
  86 #include "tests/libmemcached-1.0/setup_and_teardowns.h"
  87 #include "tests/print.h"
  88 #include "tests/debug.h"
  89 #include "tests/memc.hpp"
  90
  91 #define UUID_STRING_MAXLENGTH 36
  92
  93 #include "tests/keys.hpp"
  94
  95 #include "libmemcached/instance.hpp"
  96
  97 static memcached_st * create_single_instance_memcached(const memcached_st *original_memc, const char *options)
  98 {
  99   /*
 100     If no options are given, copy over at least the binary flag.
 101   */
 102   char options_buffer[1024]= { 0 };
 103   if (options == NULL)
 104   {
 105     if (memcached_is_binary(original_memc))
 106     {
 107       snprintf(options_buffer, sizeof(options_buffer), "--BINARY");
 108     }
 109   }
 110
 111   /*
 112    * I only want to hit _one_ server so I know the number of requests I'm
 113    * sending in the pipeline.
 114    */
 115   const memcached_instance_st * instance= memcached_server_instance_by_position(original_memc, 0);
 116
 117   char server_string[1024];
 118   int server_string_length;
 119   if (instance->type == MEMCACHED_CONNECTION_UNIX_SOCKET)
 120   {
 121     if (options)
 122     {
 123       server_string_length= snprintf(server_string, sizeof(server_string), "--SOCKET=\"%s\" %s",
 124                                      memcached_server_name(instance), options);
 125     }
 126     else
 127     {
 128       server_string_length= snprintf(server_string, sizeof(server_string), "--SOCKET=\"%s\"",
 129                                      memcached_server_name(instance));
 130     }
 131   }
 132   else
 133   {
 134     if (options)
 135     {
 136       server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d %s",
 137                                      memcached_server_name(instance), int(memcached_server_port(instance)),
 138                                      options);
 139     }
 140     else
 141     {
 142       server_string_length= snprintf(server_string, sizeof(server_string), "--server=%s:%d",
 143                                      memcached_server_name(instance), int(memcached_server_port(instance)));
 144     }
 145   }
 146
 147   if (server_string_length <= 0)
 148   {
 149     return NULL;
 150   }
 151
 152   char errror_buffer[1024];
 153   if (memcached_failed(libmemcached_check_configuration(server_string, server_string_length, errror_buffer, sizeof(errror_buffer))))
 154   {
 155     Error << "Failed to parse (" << server_string << ") " << errror_buffer;
 156     return NULL;
 157   }
 158
 159   return memcached(server_string, server_string_length);
 160 }
 161
 162
 163 test_return_t init_test(memcached_st *not_used)
 164 {
 165   memcached_st memc;
 166   (void)not_used;
 167
 168   (void)memcached_create(&memc);
 169   memcached_free(&memc);
 170
 171   return TEST_SUCCESS;
 172 }
 173
 174 #define TEST_PORT_COUNT 7
 175 in_port_t test_ports[TEST_PORT_COUNT];
 176
 177 static memcached_return_t server_display_function(const memcached_st *ptr,
 178                                                   const memcached_instance_st * server,
 179                                                   void *context)
 180 {
 181   /* Do Nothing */
 182   size_t bigger= *((size_t *)(context));
 183   (void)ptr;
 184   fatal_assert(bigger <= memcached_server_port(server));
 185   *((size_t *)(context))= memcached_server_port(server);
 186
 187   return MEMCACHED_SUCCESS;
 188 }
 189
 190 static memcached_return_t dump_server_information(const memcached_st *ptr,
 191                                                   const memcached_instance_st * instance,
 192                                                   void *context)
 193 {
 194   /* Do Nothing */
 195   FILE *stream= (FILE *)context;
 196   (void)ptr;
 197
 198   fprintf(stream, "Memcached Server: %s %u Version %u.%u.%u\n",
 199           memcached_server_name(instance),
 200           memcached_server_port(instance),
 201           instance->major_version,
 202           instance->minor_version,
 203           instance->micro_version);
 204
 205   return MEMCACHED_SUCCESS;
 206 }
 207
 208 test_return_t server_sort_test(memcached_st *ptr)
 209 {
 210   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
 211
 212   memcached_return_t rc;
 213   memcached_server_fn callbacks[1];
 214   memcached_st *local_memc;
 215   (void)ptr;
 216
 217   local_memc= memcached_create(NULL);
 218   test_true(local_memc);
 219   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 220
 221   for (uint32_t x= 0; x < TEST_PORT_COUNT; x++)
 222   {
 223     test_ports[x]= (in_port_t)random() % 64000;
 224     rc= memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0);
 225     test_compare(memcached_server_count(local_memc), x +1);
 226 #if 0 // Rewrite
 227     test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
 228 #endif
 229     test_compare(MEMCACHED_SUCCESS, rc);
 230   }
 231
 232   callbacks[0]= server_display_function;
 233   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 234
 235
 236   memcached_free(local_memc);
 237
 238   return TEST_SUCCESS;
 239 }
 240
 241 test_return_t server_sort2_test(memcached_st *ptr)
 242 {
 243   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
 244   memcached_server_fn callbacks[1];
 245   memcached_st *local_memc;
 246   const memcached_instance_st * instance;
 247   (void)ptr;
 248
 249   local_memc= memcached_create(NULL);
 250   test_true(local_memc);
 251   test_compare(MEMCACHED_SUCCESS,
 252                memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1));
 253
 254   test_compare(MEMCACHED_SUCCESS,
 255                memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43043, 0));
 256   instance= memcached_server_instance_by_position(local_memc, 0);
 257   test_compare(in_port_t(43043), memcached_server_port(instance));
 258
 259   test_compare(MEMCACHED_SUCCESS,
 260                memcached_server_add_with_weight(local_memc, "MEMCACHED_BEHAVIOR_SORT_HOSTS", 43042, 0));
 261
 262   instance= memcached_server_instance_by_position(local_memc, 0);
 263   test_compare(in_port_t(43042), memcached_server_port(instance));
 264
 265   instance= memcached_server_instance_by_position(local_memc, 1);
 266   test_compare(in_port_t(43043), memcached_server_port(instance));
 267
 268   callbacks[0]= server_display_function;
 269   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 270
 271
 272   memcached_free(local_memc);
 273
 274   return TEST_SUCCESS;
 275 }
 276
 277 test_return_t memcached_server_remove_test(memcached_st*)
 278 {
 279   const char *server_string= "--server=localhost:4444 --server=localhost:4445 --server=localhost:4446 --server=localhost:4447 --server=localhost --server=memcache1.memcache.bk.sapo.pt:11211 --server=memcache1.memcache.bk.sapo.pt:11212 --server=memcache1.memcache.bk.sapo.pt:11213 --server=memcache1.memcache.bk.sapo.pt:11214 --server=memcache2.memcache.bk.sapo.pt:11211 --server=memcache2.memcache.bk.sapo.pt:11212 --server=memcache2.memcache.bk.sapo.pt:11213 --server=memcache2.memcache.bk.sapo.pt:11214";
 280   char buffer[BUFSIZ];
 281
 282   test_compare(MEMCACHED_SUCCESS,
 283                libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
 284   memcached_st *memc= memcached(server_string, strlen(server_string));
 285   test_true(memc);
 286
 287   memcached_server_fn callbacks[1];
 288   callbacks[0]= server_print_callback;
 289   memcached_server_cursor(memc, callbacks, NULL,  1);
 290
 291   memcached_free(memc);
 292
 293   return TEST_SUCCESS;
 294 }
 295
 296 static memcached_return_t server_display_unsort_function(const memcached_st*,
 297                                                          const memcached_instance_st * server,
 298                                                          void *context)
 299 {
 300   /* Do Nothing */
 301   uint32_t x= *((uint32_t *)(context));
 302
 303   if (! (test_ports[x] == memcached_server_port(server)))
 304   {
 305     fprintf(stderr, "%lu -> %lu\n", (unsigned long)test_ports[x], (unsigned long)memcached_server_port(server));
 306     return MEMCACHED_FAILURE;
 307   }
 308
 309   *((uint32_t *)(context))= ++x;
 310
 311   return MEMCACHED_SUCCESS;
 312 }
 313
 314 test_return_t server_unsort_test(memcached_st *ptr)
 315 {
 316   size_t counter= 0; /* Prime the value for the test_true in server_display_function */
 317   size_t bigger= 0; /* Prime the value for the test_true in server_display_function */
 318   memcached_server_fn callbacks[1];
 319   memcached_st *local_memc;
 320   (void)ptr;
 321
 322   local_memc= memcached_create(NULL);
 323   test_true(local_memc);
 324
 325   for (uint32_t x= 0; x < TEST_PORT_COUNT; x++)
 326   {
 327     test_ports[x]= (in_port_t)(random() % 64000);
 328     test_compare(MEMCACHED_SUCCESS,
 329                  memcached_server_add_with_weight(local_memc, "localhost", test_ports[x], 0));
 330     test_compare(memcached_server_count(local_memc), x +1);
 331 #if 0 // Rewrite
 332     test_true(memcached_server_list_count(memcached_server_list(local_memc)) == x+1);
 333 #endif
 334   }
 335
 336   callbacks[0]= server_display_unsort_function;
 337   memcached_server_cursor(local_memc, callbacks, (void *)&counter,  1);
 338
 339   /* Now we sort old data! */
 340   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SORT_HOSTS, 1);
 341   callbacks[0]= server_display_function;
 342   memcached_server_cursor(local_memc, callbacks, (void *)&bigger,  1);
 343
 344
 345   memcached_free(local_memc);
 346
 347   return TEST_SUCCESS;
 348 }
 349
 350 test_return_t allocation_test(memcached_st *not_used)
 351 {
 352   (void)not_used;
 353   memcached_st *memc;
 354   memc= memcached_create(NULL);
 355   test_true(memc);
 356   memcached_free(memc);
 357
 358   return TEST_SUCCESS;
 359 }
 360
 361 test_return_t clone_test(memcached_st *memc)
 362 {
 363   /* All null? */
 364   {
 365     memcached_st *memc_clone;
 366     memc_clone= memcached_clone(NULL, NULL);
 367     test_true(memc_clone);
 368     memcached_free(memc_clone);
 369   }
 370
 371   /* Can we init from null? */
 372   {
 373     memcached_st *memc_clone;
 374     memc_clone= memcached_clone(NULL, memc);
 375     test_true(memc_clone);
 376
 377     { // Test allocators
 378       test_true(memc_clone->allocators.free == memc->allocators.free);
 379       test_true(memc_clone->allocators.malloc == memc->allocators.malloc);
 380       test_true(memc_clone->allocators.realloc == memc->allocators.realloc);
 381       test_true(memc_clone->allocators.calloc == memc->allocators.calloc);
 382     }
 383
 384     test_true(memc_clone->connect_timeout == memc->connect_timeout);
 385     test_true(memc_clone->delete_trigger == memc->delete_trigger);
 386     test_true(memc_clone->distribution == memc->distribution);
 387     { // Test all of the flags
 388       test_true(memc_clone->flags.no_block == memc->flags.no_block);
 389       test_true(memc_clone->flags.tcp_nodelay == memc->flags.tcp_nodelay);
 390       test_true(memc_clone->flags.support_cas == memc->flags.support_cas);
 391       test_true(memc_clone->flags.buffer_requests == memc->flags.buffer_requests);
 392       test_true(memc_clone->flags.use_sort_hosts == memc->flags.use_sort_hosts);
 393       test_true(memc_clone->flags.verify_key == memc->flags.verify_key);
 394       test_true(memc_clone->ketama.weighted_ == memc->ketama.weighted_);
 395       test_true(memc_clone->flags.binary_protocol == memc->flags.binary_protocol);
 396       test_true(memc_clone->flags.hash_with_namespace == memc->flags.hash_with_namespace);
 397       test_true(memc_clone->flags.reply == memc->flags.reply);
 398       test_true(memc_clone->flags.use_udp == memc->flags.use_udp);
 399       test_true(memc_clone->flags.auto_eject_hosts == memc->flags.auto_eject_hosts);
 400       test_true(memc_clone->flags.randomize_replica_read == memc->flags.randomize_replica_read);
 401     }
 402     test_true(memc_clone->get_key_failure == memc->get_key_failure);
 403     test_true(hashkit_compare(&memc_clone->hashkit, &memc->hashkit));
 404     test_true(memc_clone->io_bytes_watermark == memc->io_bytes_watermark);
 405     test_true(memc_clone->io_msg_watermark == memc->io_msg_watermark);
 406     test_true(memc_clone->io_key_prefetch == memc->io_key_prefetch);
 407     test_true(memc_clone->on_cleanup == memc->on_cleanup);
 408     test_true(memc_clone->on_clone == memc->on_clone);
 409     test_true(memc_clone->poll_timeout == memc->poll_timeout);
 410     test_true(memc_clone->rcv_timeout == memc->rcv_timeout);
 411     test_true(memc_clone->recv_size == memc->recv_size);
 412     test_true(memc_clone->retry_timeout == memc->retry_timeout);
 413     test_true(memc_clone->send_size == memc->send_size);
 414     test_true(memc_clone->server_failure_limit == memc->server_failure_limit);
 415     test_true(memc_clone->snd_timeout == memc->snd_timeout);
 416     test_true(memc_clone->user_data == memc->user_data);
 417
 418     memcached_free(memc_clone);
 419   }
 420
 421   /* Can we init from struct? */
 422   {
 423     memcached_st declared_clone;
 424     memcached_st *memc_clone;
 425     memset(&declared_clone, 0 , sizeof(memcached_st));
 426     memc_clone= memcached_clone(&declared_clone, NULL);
 427     test_true(memc_clone);
 428     memcached_free(memc_clone);
 429   }
 430
 431   /* Can we init from struct? */
 432   {
 433     memcached_st declared_clone;
 434     memcached_st *memc_clone;
 435     memset(&declared_clone, 0 , sizeof(memcached_st));
 436     memc_clone= memcached_clone(&declared_clone, memc);
 437     test_true(memc_clone);
 438     memcached_free(memc_clone);
 439   }
 440
 441   return TEST_SUCCESS;
 442 }
 443
 444 test_return_t userdata_test(memcached_st *memc)
 445 {
 446   void* foo= NULL;
 447   test_false(memcached_set_user_data(memc, foo));
 448   test_true(memcached_get_user_data(memc) == foo);
 449   test_true(memcached_set_user_data(memc, NULL) == foo);
 450
 451   return TEST_SUCCESS;
 452 }
 453
 454 test_return_t connection_test(memcached_st *memc)
 455 {
 456   test_compare(MEMCACHED_SUCCESS,
 457                memcached_server_add_with_weight(memc, "localhost", 0, 0));
 458
 459   return TEST_SUCCESS;
 460 }
 461
 462 test_return_t libmemcached_string_behavior_test(memcached_st *)
 463 {
 464   for (int x= MEMCACHED_BEHAVIOR_NO_BLOCK; x < int(MEMCACHED_BEHAVIOR_MAX); ++x)
 465   {
 466     test_true(libmemcached_string_behavior(memcached_behavior_t(x)));
 467   }
 468   test_compare(37, int(MEMCACHED_BEHAVIOR_MAX));
 469
 470   return TEST_SUCCESS;
 471 }
 472
 473 test_return_t libmemcached_string_distribution_test(memcached_st *)
 474 {
 475   for (int x= MEMCACHED_DISTRIBUTION_MODULA; x < int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX); ++x)
 476   {
 477     test_true(libmemcached_string_distribution(memcached_server_distribution_t(x)));
 478   }
 479   test_compare(7, int(MEMCACHED_DISTRIBUTION_CONSISTENT_MAX));
 480
 481   return TEST_SUCCESS;
 482 }
 483
 484 test_return_t memcached_return_t_TEST(memcached_st *memc)
 485 {
 486   uint32_t values[] = { 851992627U, 2337886783U, 4109241422U, 4001849190U,
 487                         982370485U, 1263635348U, 4242906218U, 3829656100U,
 488                         1891735253U, 334139633U, 2257084983U, 3351789013U,
 489                         13199785U, 2542027183U, 1097051614U, 199566778U,
 490                         2748246961U, 2465192557U, 1664094137U, 2405439045U,
 491                         1842224848U, 692413798U, 3479807801U, 919913813U,
 492                         4269430871U, 610793021U, 527273862U, 1437122909U,
 493                         2300930706U, 2943759320U, 674306647U, 2400528935U,
 494                         54481931U, 4186304426U, 1741088401U, 2979625118U,
 495                         4159057246U, 3425930182U, 2593724503U,  1868899624U,
 496                         1769812374U, 2302537950U, 1110330676U, 3365377466U,
 497                         1336171666U, 3021258493U, 2334992265U, 3861994737U,
 498                         3582734124U, 3365377466U };
 499
 500   // You have updated the memcache_error messages but not updated docs/tests.
 501   for (int rc= int(MEMCACHED_SUCCESS); rc < int(MEMCACHED_MAXIMUM_RETURN); ++rc)
 502   {
 503     uint32_t hash_val;
 504     const char *msg=  memcached_strerror(memc, memcached_return_t(rc));
 505     hash_val= memcached_generate_hash_value(msg, strlen(msg),
 506                                             MEMCACHED_HASH_JENKINS);
 507     if (values[rc] != hash_val)
 508     {
 509       fprintf(stderr, "\n\nYou have updated memcached_return_t without updating the memcached_return_t_TEST\n");
 510       fprintf(stderr, "%u, %s, (%u)\n\n", (uint32_t)rc, memcached_strerror(memc, memcached_return_t(rc)), hash_val);
 511     }
 512     test_compare(values[rc], hash_val);
 513   }
 514   test_compare(49, int(MEMCACHED_MAXIMUM_RETURN));
 515
 516   return TEST_SUCCESS;
 517 }
 518
 519 test_return_t set_test(memcached_st *memc)
 520 {
 521   memcached_return_t rc= memcached_set(memc,
 522                                        test_literal_param("foo"),
 523                                        test_literal_param("when we sanitize"),
 524                                        time_t(0), (uint32_t)0);
 525   test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
 526
 527   return TEST_SUCCESS;
 528 }
 529
 530 test_return_t append_test(memcached_st *memc)
 531 {
 532   memcached_return_t rc;
 533   const char *in_value= "we";
 534   size_t value_length;
 535   uint32_t flags;
 536
 537   test_compare(MEMCACHED_SUCCESS,
 538                memcached_flush(memc, 0));
 539
 540   test_compare(MEMCACHED_SUCCESS,
 541                memcached_set(memc,
 542                              test_literal_param(__func__),
 543                              in_value, strlen(in_value),
 544                              time_t(0), uint32_t(0)));
 545
 546   test_compare(MEMCACHED_SUCCESS,
 547                memcached_append(memc,
 548                                 test_literal_param(__func__),
 549                                 " the", strlen(" the"),
 550                                 time_t(0), uint32_t(0)));
 551
 552   test_compare(MEMCACHED_SUCCESS,
 553                memcached_append(memc,
 554                                 test_literal_param(__func__),
 555                                 " people", strlen(" people"),
 556                                 time_t(0), uint32_t(0)));
 557
 558   char *out_value= memcached_get(memc,
 559                                  test_literal_param(__func__),
 560                                  &value_length, &flags, &rc);
 561   test_memcmp(out_value, "we the people", strlen("we the people"));
 562   test_compare(strlen("we the people"), value_length);
 563   test_compare(MEMCACHED_SUCCESS, rc);
 564   free(out_value);
 565
 566   return TEST_SUCCESS;
 567 }
 568
 569 test_return_t append_binary_test(memcached_st *memc)
 570 {
 571   uint32_t store_list[] = { 23, 56, 499, 98, 32847, 0 };
 572
 573   test_compare(MEMCACHED_SUCCESS,
 574                memcached_flush(memc, 0));
 575
 576   test_compare(MEMCACHED_SUCCESS,
 577                memcached_set(memc,
 578                              test_literal_param(__func__),
 579                              NULL, 0,
 580                              time_t(0), uint32_t(0)));
 581
 582   size_t count= 0;
 583   for (uint32_t x= 0; store_list[x] ; x++)
 584   {
 585     test_compare(MEMCACHED_SUCCESS,
 586                  memcached_append(memc,
 587                          test_literal_param(__func__),
 588                          (char *)&store_list[x], sizeof(uint32_t),
 589                          time_t(0), uint32_t(0)));
 590     count++;
 591   }
 592
 593   size_t value_length;
 594   uint32_t flags;
 595   memcached_return_t rc;
 596   uint32_t *value= (uint32_t *)memcached_get(memc,
 597                                              test_literal_param(__func__),
 598                                              &value_length, &flags, &rc);
 599   test_compare(value_length, sizeof(uint32_t) * count);
 600   test_compare(MEMCACHED_SUCCESS, rc);
 601
 602   for (uint32_t counter= uint32_t(count), *ptr= value; counter; counter--)
 603   {
 604     test_compare(*ptr, store_list[count - counter]);
 605     ptr++;
 606   }
 607   free(value);
 608
 609   return TEST_SUCCESS;
 610 }
 611
 612 test_return_t memcached_mget_mixed_memcached_get_TEST(memcached_st *memc)
 613 {
 614   keys_st keys(200);
 615
 616   for (libtest::vchar_ptr_t::iterator iter= keys.begin();
 617        iter != keys.end();
 618        ++iter)
 619   {
 620     test_compare_hint(MEMCACHED_SUCCESS,
 621                       memcached_set(memc,
 622                                     (*iter), 36,
 623                                     NULL, 0,
 624                                     time_t(0), uint32_t(0)),
 625                       memcached_last_error_message(memc));
 626   }
 627
 628   for (ptrdiff_t loop= 0; loop < 20; loop++)
 629   {
 630     if (random() %2)
 631     {
 632       test_compare(MEMCACHED_SUCCESS,
 633                    memcached_mget(memc, keys.keys_ptr(), keys.lengths_ptr(), keys.size()));
 634
 635       memcached_result_st *results= memcached_result_create(memc, NULL);
 636       test_true(results);
 637
 638       size_t result_count= 0;
 639       memcached_return_t rc;
 640       while (memcached_fetch_result(memc, results, &rc))
 641       {
 642         result_count++;
 643       }
 644       test_true(keys.size() >= result_count);
 645     }
 646     else
 647     {
 648       int which_key= random() % int(keys.size());
 649       size_t value_length;
 650       uint32_t flags;
 651       memcached_return_t rc;
 652       char *out_value= memcached_get(memc, keys.key_at(which_key), keys.length_at(which_key),
 653                                      &value_length, &flags, &rc);
 654       if (rc == MEMCACHED_NOTFOUND)
 655       { } // It is possible that the value has been purged.
 656       else
 657       {
 658         test_compare(MEMCACHED_SUCCESS, rc);
 659       }
 660       test_null(out_value);
 661       test_zero(value_length);
 662       test_zero(flags);
 663     }
 664   }
 665
 666   return TEST_SUCCESS;
 667 }
 668
 669 test_return_t cas2_test(memcached_st *memc)
 670 {
 671   const char *keys[]= {"fudge", "son", "food"};
 672   size_t key_length[]= {5, 3, 4};
 673   const char *value= "we the people";
 674   size_t value_length= strlen("we the people");
 675
 676   test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
 677
 678   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
 679
 680   for (uint32_t x= 0; x < 3; x++)
 681   {
 682     test_compare(MEMCACHED_SUCCESS,
 683                  memcached_set(memc, keys[x], key_length[x],
 684                                keys[x], key_length[x],
 685                                time_t(50), uint32_t(9)));
 686   }
 687
 688   test_compare(MEMCACHED_SUCCESS,
 689                memcached_mget(memc, keys, key_length, 3));
 690
 691   memcached_result_st *results= memcached_result_create(memc, NULL);
 692   test_true(results);
 693
 694   memcached_return_t rc;
 695   results= memcached_fetch_result(memc, results, &rc);
 696   test_true(results);
 697   test_true(results->item_cas);
 698   test_compare(MEMCACHED_SUCCESS, rc);
 699   test_true(memcached_result_cas(results));
 700
 701   test_memcmp(value, "we the people", strlen("we the people"));
 702   test_compare(strlen("we the people"), value_length);
 703   test_compare(MEMCACHED_SUCCESS, rc);
 704
 705   memcached_result_free(results);
 706
 707   return TEST_SUCCESS;
 708 }
 709
 710 test_return_t cas_test(memcached_st *memc)
 711 {
 712   const char* keys[2] = { __func__, NULL };
 713   size_t keylengths[2] = { strlen(__func__), 0 };
 714
 715   memcached_result_st results_obj;
 716
 717   test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
 718
 719   test_skip(true, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
 720
 721   test_compare(MEMCACHED_SUCCESS,
 722                memcached_set(memc,
 723                              test_literal_param(__func__),
 724                              test_literal_param("we the people"),
 725                              (time_t)0, (uint32_t)0));
 726
 727   test_compare(MEMCACHED_SUCCESS,
 728                memcached_mget(memc, keys, keylengths, 1));
 729
 730   memcached_result_st *results= memcached_result_create(memc, &results_obj);
 731   test_true(results);
 732
 733   memcached_return_t rc;
 734   results= memcached_fetch_result(memc, &results_obj, &rc);
 735   test_true(results);
 736   test_compare(MEMCACHED_SUCCESS, rc);
 737   test_true(memcached_result_cas(results));
 738   test_memcmp("we the people", memcached_result_value(results), test_literal_param_size("we the people"));
 739   test_compare(test_literal_param_size("we the people"),
 740                strlen(memcached_result_value(results)));
 741
 742   uint64_t cas= memcached_result_cas(results);
 743
 744 #if 0
 745   results= memcached_fetch_result(memc, &results_obj, &rc);
 746   test_true(rc == MEMCACHED_END);
 747   test_true(results == NULL);
 748 #endif
 749
 750   test_compare(MEMCACHED_SUCCESS,
 751                memcached_cas(memc,
 752                              test_literal_param(__func__),
 753                              test_literal_param("change the value"),
 754                              0, 0, cas));
 755
 756   /*
 757    * The item will have a new cas value, so try to set it again with the old
 758    * value. This should fail!
 759    */
 760   test_compare(MEMCACHED_DATA_EXISTS,
 761                memcached_cas(memc,
 762                              test_literal_param(__func__),
 763                              test_literal_param("change the value"),
 764                              0, 0, cas));
 765
 766   memcached_result_free(&results_obj);
 767
 768   return TEST_SUCCESS;
 769 }
 770
 771
 772 test_return_t prepend_test(memcached_st *memc)
 773 {
 774   const char *key= "fig";
 775   const char *value= "people";
 776
 777   test_compare(MEMCACHED_SUCCESS,
 778                memcached_flush(memc, 0));
 779
 780   test_compare(MEMCACHED_SUCCESS,
 781                memcached_set(memc, key, strlen(key),
 782                              value, strlen(value),
 783                              time_t(0), uint32_t(0)));
 784
 785   test_compare(MEMCACHED_SUCCESS,
 786                memcached_prepend(memc, key, strlen(key),
 787                                  "the ", strlen("the "),
 788                                  time_t(0), uint32_t(0)));
 789
 790   test_compare(MEMCACHED_SUCCESS,
 791                memcached_prepend(memc, key, strlen(key),
 792                                  "we ", strlen("we "),
 793                                  time_t(0), uint32_t(0)));
 794
 795   size_t value_length;
 796   uint32_t flags;
 797   memcached_return_t rc;
 798   char *out_value= memcached_get(memc, key, strlen(key),
 799                        &value_length, &flags, &rc);
 800   test_memcmp(out_value, "we the people", strlen("we the people"));
 801   test_compare(strlen("we the people"), value_length);
 802   test_compare(MEMCACHED_SUCCESS, rc);
 803   free(out_value);
 804
 805   return TEST_SUCCESS;
 806 }
 807
 808 /*
 809   Set the value, then quit to make sure it is flushed.
 810   Come back in and test that add fails.
 811 */
 812 test_return_t memcached_add_SUCCESS_TEST(memcached_st *memc)
 813 {
 814   memcached_return_t rc;
 815   test_null(memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc));
 816   test_compare(MEMCACHED_NOTFOUND, rc);
 817
 818   test_compare(MEMCACHED_SUCCESS,
 819                memcached_add(memc,
 820                              test_literal_param(__func__),
 821                              test_literal_param("try something else"),
 822                              time_t(0), uint32_t(0)));
 823
 824   return TEST_SUCCESS;
 825 }
 826
 827 test_return_t regression_1067242_TEST(memcached_st *memc)
 828 {
 829   test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
 830                                                 test_literal_param(__func__),
 831                                                 test_literal_param("-2"),
 832                                                 0, 0));
 833
 834   memcached_return_t rc;
 835   char* value;
 836   test_true((value= memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc)));
 837   test_compare(MEMCACHED_SUCCESS, rc);
 838   free(value);
 839
 840   for (size_t x= 0; x < 10; x++)
 841   {
 842     uint64_t new_number;
 843     test_compare(MEMCACHED_CLIENT_ERROR,
 844                  memcached_increment(memc,
 845                                      test_literal_param(__func__), 1, &new_number));
 846     test_compare(MEMCACHED_CLIENT_ERROR, memcached_last_error(memc));
 847     test_true((value= memcached_get(memc, test_literal_param(__func__), NULL, NULL, &rc)));
 848     test_compare(MEMCACHED_SUCCESS, rc);
 849     free(value);
 850   }
 851
 852   return TEST_SUCCESS;
 853 }
 854
 855 /*
 856   Set the value, then quit to make sure it is flushed.
 857   Come back in and test that add fails.
 858 */
 859 test_return_t add_test(memcached_st *memc)
 860 {
 861   test_compare(return_value_based_on_buffering(memc),
 862                memcached_set(memc,
 863                              test_literal_param(__func__),
 864                              test_literal_param("when we sanitize"),
 865                              time_t(0), uint32_t(0)));
 866
 867   memcached_quit(memc);
 868
 869   size_t value_length;
 870   uint32_t flags;
 871   memcached_return_t rc;
 872   char *check_value= memcached_get(memc,
 873                                    test_literal_param(__func__),
 874                                    &value_length, &flags, &rc);
 875   test_memcmp(check_value, "when we sanitize", strlen("when we sanitize"));
 876   test_compare(test_literal_param_size("when we sanitize"), value_length);
 877   test_compare(MEMCACHED_SUCCESS, rc);
 878   free(check_value);
 879
 880   test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_DATA_EXISTS : MEMCACHED_NOTSTORED,
 881                memcached_add(memc,
 882                              test_literal_param(__func__),
 883                              test_literal_param("try something else"),
 884                              time_t(0), uint32_t(0)));
 885
 886   return TEST_SUCCESS;
 887 }
 888
 889 /*
 890 ** There was a problem of leaking filedescriptors in the initial release
 891 ** of MacOSX 10.5. This test case triggers the problem. On some Solaris
 892 ** systems it seems that the kernel is slow on reclaiming the resources
 893 ** because the connects starts to time out (the test doesn't do much
 894 ** anyway, so just loop 10 iterations)
 895 */
 896 test_return_t add_wrapper(memcached_st *memc)
 897 {
 898   unsigned int max= 10000;
 899 #ifdef __sun
 900   max= 10;
 901 #endif
 902 #ifdef __APPLE__
 903   max= 10;
 904 #endif
 905
 906   for (uint32_t x= 0; x < max; x++)
 907   {
 908     add_test(memc);
 909   }
 910
 911   return TEST_SUCCESS;
 912 }
 913
 914 test_return_t replace_test(memcached_st *memc)
 915 {
 916   test_compare(return_value_based_on_buffering(memc),
 917                memcached_set(memc,
 918                              test_literal_param(__func__),
 919                              test_literal_param("when we sanitize"),
 920                              time_t(0), uint32_t(0)));
 921
 922   test_compare(MEMCACHED_SUCCESS,
 923                memcached_replace(memc,
 924                                  test_literal_param(__func__),
 925                                  test_literal_param("first we insert some data"),
 926                                  time_t(0), uint32_t(0)));
 927
 928   return TEST_SUCCESS;
 929 }
 930
 931 test_return_t delete_test(memcached_st *memc)
 932 {
 933   test_compare(return_value_based_on_buffering(memc),
 934                memcached_set(memc,
 935                              test_literal_param(__func__),
 936                              test_literal_param("when we sanitize"),
 937                              time_t(0), uint32_t(0)));
 938
 939   test_compare(return_value_based_on_buffering(memc),
 940                memcached_delete(memc,
 941                                 test_literal_param(__func__),
 942                                 time_t(0)));
 943
 944   return TEST_SUCCESS;
 945 }
 946
 947 test_return_t flush_test(memcached_st *memc)
 948 {
 949   uint64_t query_id= memcached_query_id(memc);
 950   test_compare(MEMCACHED_SUCCESS,
 951                memcached_flush(memc, 0));
 952   test_compare(query_id +1, memcached_query_id(memc));
 953
 954   return TEST_SUCCESS;
 955 }
 956
 957 static memcached_return_t  server_function(const memcached_st *,
 958                                            const memcached_instance_st *,
 959                                            void *)
 960 {
 961   /* Do Nothing */
 962   return MEMCACHED_SUCCESS;
 963 }
 964
 965 test_return_t memcached_server_cursor_test(memcached_st *memc)
 966 {
 967   char context[10];
 968   strncpy(context, "foo bad", sizeof(context));
 969   memcached_server_fn callbacks[1];
 970
 971   callbacks[0]= server_function;
 972   memcached_server_cursor(memc, callbacks, context,  1);
 973   return TEST_SUCCESS;
 974 }
 975
 976 test_return_t bad_key_test(memcached_st *memc)
 977 {
 978   memcached_return_t rc;
 979   const char *key= "foo bad";
 980   uint32_t flags;
 981
 982   uint64_t query_id= memcached_query_id(memc);
 983
 984   // Just skip if we are in binary mode.
 985   test_skip(false, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
 986
 987   test_compare(query_id, memcached_query_id(memc)); // We should not increase the query_id for memcached_behavior_get()
 988
 989   memcached_st *memc_clone= memcached_clone(NULL, memc);
 990   test_true(memc_clone);
 991
 992   query_id= memcached_query_id(memc_clone);
 993   test_compare(MEMCACHED_SUCCESS,
 994                memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
 995   test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
 996   ASSERT_TRUE(memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY));
 997
 998   /* All keys are valid in the binary protocol (except for length) */
 999   if (memcached_behavior_get(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == false)
1000   {
1001     uint64_t before_query_id= memcached_query_id(memc_clone);
1002     {
1003       size_t string_length;
1004       char *string= memcached_get(memc_clone, key, strlen(key),
1005                                   &string_length, &flags, &rc);
1006       test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
1007       test_zero(string_length);
1008       test_false(string);
1009     }
1010     test_compare(before_query_id +1, memcached_query_id(memc_clone));
1011
1012     query_id= memcached_query_id(memc_clone);
1013     test_compare(MEMCACHED_SUCCESS,
1014                  memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, false));
1015     test_compare(query_id, memcached_query_id(memc_clone)); // We should not increase the query_id for memcached_behavior_set()
1016     {
1017       size_t string_length;
1018       char *string= memcached_get(memc_clone, key, strlen(key),
1019                                   &string_length, &flags, &rc);
1020       test_compare(MEMCACHED_NOTFOUND, rc);
1021       test_zero(string_length);
1022       test_false(string);
1023     }
1024
1025     /* Test multi key for bad keys */
1026     const char *keys[] = { "GoodKey", "Bad Key", "NotMine" };
1027     size_t key_lengths[] = { 7, 7, 7 };
1028     query_id= memcached_query_id(memc_clone);
1029     test_compare(MEMCACHED_SUCCESS,
1030                  memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
1031     test_compare(query_id, memcached_query_id(memc_clone));
1032
1033     query_id= memcached_query_id(memc_clone);
1034     test_compare(MEMCACHED_BAD_KEY_PROVIDED,
1035                  memcached_mget(memc_clone, keys, key_lengths, 3));
1036     test_compare(query_id +1, memcached_query_id(memc_clone));
1037
1038     query_id= memcached_query_id(memc_clone);
1039     // Grouping keys are not required to follow normal key behaviors
1040     test_compare(MEMCACHED_SUCCESS,
1041                  memcached_mget_by_key(memc_clone, "foo daddy", 9, keys, key_lengths, 1));
1042     test_compare(query_id +1, memcached_query_id(memc_clone));
1043
1044     /* The following test should be moved to the end of this function when the
1045        memcached server is updated to allow max size length of the keys in the
1046        binary protocol
1047     */
1048     test_compare(MEMCACHED_SUCCESS,
1049                  memcached_callback_set(memc_clone, MEMCACHED_CALLBACK_NAMESPACE, NULL));
1050
1051     libtest::vchar_t longkey;
1052     {
1053       libtest::vchar_t::iterator it= longkey.begin();
1054       longkey.insert(it, MEMCACHED_MAX_KEY, 'a');
1055     }
1056
1057     test_compare(longkey.size(), size_t(MEMCACHED_MAX_KEY));
1058     {
1059       size_t string_length;
1060       // We subtract 1
1061       test_null(memcached_get(memc_clone, &longkey[0], longkey.size() -1, &string_length, &flags, &rc));
1062       test_compare(MEMCACHED_NOTFOUND, rc);
1063       test_zero(string_length);
1064
1065       test_null(memcached_get(memc_clone, &longkey[0], longkey.size(), &string_length, &flags, &rc));
1066       test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
1067       test_zero(string_length);
1068     }
1069   }
1070
1071   /* Make sure zero length keys are marked as bad */
1072   {
1073     test_compare(MEMCACHED_SUCCESS,
1074                  memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_VERIFY_KEY, true));
1075     size_t string_length;
1076     char *string= memcached_get(memc_clone, key, 0,
1077                                 &string_length, &flags, &rc);
1078     test_compare(MEMCACHED_BAD_KEY_PROVIDED, rc);
1079     test_zero(string_length);
1080     test_false(string);
1081   }
1082
1083   memcached_free(memc_clone);
1084
1085   return TEST_SUCCESS;
1086 }
1087
1088 #define READ_THROUGH_VALUE "set for me"
1089 static memcached_return_t read_through_trigger(memcached_st *, // memc
1090                                                char *, // key
1091                                                size_t, //  key_length,
1092                                                memcached_result_st *result)
1093 {
1094   return memcached_result_set_value(result, READ_THROUGH_VALUE, strlen(READ_THROUGH_VALUE));
1095 }
1096
1097 #ifndef __INTEL_COMPILER
1098 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
1099 #endif
1100
1101 test_return_t read_through(memcached_st *memc)
1102 {
1103   memcached_trigger_key_fn cb= (memcached_trigger_key_fn)read_through_trigger;
1104
1105   size_t string_length;
1106   uint32_t flags;
1107   memcached_return_t rc;
1108   char *string= memcached_get(memc,
1109                               test_literal_param(__func__),
1110                               &string_length, &flags, &rc);
1111
1112   test_compare(MEMCACHED_NOTFOUND, rc);
1113   test_false(string_length);
1114   test_false(string);
1115
1116   test_compare(MEMCACHED_SUCCESS,
1117                memcached_callback_set(memc, MEMCACHED_CALLBACK_GET_FAILURE, *(void **)&cb));
1118
1119   string= memcached_get(memc,
1120                         test_literal_param(__func__),
1121                         &string_length, &flags, &rc);
1122
1123   test_compare(MEMCACHED_SUCCESS, rc);
1124   test_compare(sizeof(READ_THROUGH_VALUE) -1, string_length);
1125   test_compare(0, string[sizeof(READ_THROUGH_VALUE) -1]);
1126   test_strcmp(READ_THROUGH_VALUE, string);
1127   free(string);
1128
1129   string= memcached_get(memc,
1130                         test_literal_param(__func__),
1131                         &string_length, &flags, &rc);
1132
1133   test_compare(MEMCACHED_SUCCESS, rc);
1134   test_true(string);
1135   test_compare(string_length, sizeof(READ_THROUGH_VALUE) -1);
1136   test_true(string[sizeof(READ_THROUGH_VALUE) -1] == 0);
1137   test_strcmp(READ_THROUGH_VALUE, string);
1138   free(string);
1139
1140   return TEST_SUCCESS;
1141 }
1142
1143 test_return_t set_test2(memcached_st *memc)
1144 {
1145   for (uint32_t x= 0; x < 10; x++)
1146   {
1147     test_compare(return_value_based_on_buffering(memc),
1148                  memcached_set(memc,
1149                                test_literal_param("foo"),
1150                                test_literal_param("train in the brain"),
1151                                time_t(0), uint32_t(0)));
1152   }
1153
1154   return TEST_SUCCESS;
1155 }
1156
1157 test_return_t set_test3(memcached_st *memc)
1158 {
1159   size_t value_length= 8191;
1160
1161   libtest::vchar_t value;
1162   value.reserve(value_length);
1163   for (uint32_t x= 0; x < value_length; x++)
1164   {
1165     value.push_back(char(x % 127));
1166   }
1167
1168   /* The dump test relies on there being at least 32 items in memcached */
1169   for (uint32_t x= 0; x < 32; x++)
1170   {
1171     char key[16];
1172
1173     snprintf(key, sizeof(key), "foo%u", x);
1174
1175     uint64_t query_id= memcached_query_id(memc);
1176     test_compare(return_value_based_on_buffering(memc),
1177                  memcached_set(memc, key, strlen(key),
1178                                &value[0], value.size(),
1179                                time_t(0), uint32_t(0)));
1180     test_compare(query_id +1, memcached_query_id(memc));
1181   }
1182
1183   return TEST_SUCCESS;
1184 }
1185
1186 test_return_t mget_end(memcached_st *memc)
1187 {
1188   const char *keys[]= { "foo", "foo2" };
1189   size_t lengths[]= { 3, 4 };
1190   const char *values[]= { "fjord", "41" };
1191
1192   // Set foo and foo2
1193   for (size_t x= 0; x < test_array_length(keys); x++)
1194   {
1195     test_compare(MEMCACHED_SUCCESS,
1196                  memcached_set(memc,
1197                                keys[x], lengths[x],
1198                                values[x], strlen(values[x]),
1199                                time_t(0), uint32_t(0)));
1200   }
1201
1202   char *string;
1203   size_t string_length;
1204   uint32_t flags;
1205
1206   // retrieve both via mget
1207   test_compare(MEMCACHED_SUCCESS,
1208                memcached_mget(memc,
1209                               keys, lengths,
1210                               test_array_length(keys)));
1211
1212   char key[MEMCACHED_MAX_KEY];
1213   size_t key_length;
1214   memcached_return_t rc;
1215
1216   // this should get both
1217   for (size_t x= 0; x < test_array_length(keys); x++)
1218   {
1219     string= memcached_fetch(memc, key, &key_length, &string_length,
1220                             &flags, &rc);
1221     test_compare(MEMCACHED_SUCCESS, rc);
1222     int val = 0;
1223     if (key_length == 4)
1224     {
1225       val= 1;
1226     }
1227
1228     test_compare(string_length, strlen(values[val]));
1229     test_true(strncmp(values[val], string, string_length) == 0);
1230     free(string);
1231   }
1232
1233   // this should indicate end
1234   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1235   test_compare(MEMCACHED_END, rc);
1236   test_null(string);
1237
1238   // now get just one
1239   test_compare(MEMCACHED_SUCCESS,
1240                memcached_mget(memc, keys, lengths, 1));
1241
1242   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1243   test_compare(key_length, lengths[0]);
1244   test_true(strncmp(keys[0], key, key_length) == 0);
1245   test_compare(string_length, strlen(values[0]));
1246   test_true(strncmp(values[0], string, string_length) == 0);
1247   test_compare(MEMCACHED_SUCCESS, rc);
1248   free(string);
1249
1250   // this should indicate end
1251   string= memcached_fetch(memc, key, &key_length, &string_length, &flags, &rc);
1252   test_compare(MEMCACHED_END, rc);
1253   test_null(string);
1254
1255   return TEST_SUCCESS;
1256 }
1257
1258 /* Do not copy the style of this code, I just access hosts to testthis function */
1259 test_return_t stats_servername_test(memcached_st *memc)
1260 {
1261   memcached_stat_st memc_stat;
1262   const memcached_instance_st * instance=
1263     memcached_server_instance_by_position(memc, 0);
1264
1265   if (LIBMEMCACHED_WITH_SASL_SUPPORT and memcached_get_sasl_callbacks(memc))
1266   {
1267     return TEST_SKIPPED;
1268   }
1269
1270   test_compare(MEMCACHED_SUCCESS, memcached_stat_servername(&memc_stat, NULL,
1271                                                             memcached_server_name(instance),
1272                                                             memcached_server_port(instance)));
1273
1274   return TEST_SUCCESS;
1275 }
1276
1277 test_return_t increment_test(memcached_st *memc)
1278 {
1279   uint64_t new_number;
1280
1281   test_compare(MEMCACHED_SUCCESS,
1282                memcached_set(memc,
1283                              test_literal_param("number"),
1284                              test_literal_param("0"),
1285                              (time_t)0, (uint32_t)0));
1286
1287   test_compare(MEMCACHED_SUCCESS,
1288                memcached_increment(memc, test_literal_param("number"), 1, &new_number));
1289   test_compare(uint64_t(1), new_number);
1290
1291   test_compare(MEMCACHED_SUCCESS,
1292                memcached_increment(memc, test_literal_param("number"), 1, &new_number));
1293   test_compare(uint64_t(2), new_number);
1294
1295   return TEST_SUCCESS;
1296 }
1297
1298 static test_return_t __increment_with_initial_test(memcached_st *memc, uint64_t initial)
1299 {
1300   uint64_t new_number;
1301
1302   test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
1303
1304   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
1305   {
1306     test_compare(MEMCACHED_SUCCESS,
1307                  memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
1308     test_compare(new_number, initial);
1309
1310     test_compare(MEMCACHED_SUCCESS,
1311                  memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
1312     test_compare(new_number, (initial +1));
1313   }
1314   else
1315   {
1316     test_compare(MEMCACHED_INVALID_ARGUMENTS,
1317                  memcached_increment_with_initial(memc, test_literal_param("number"), 1, initial, 0, &new_number));
1318   }
1319
1320   return TEST_SUCCESS;
1321 }
1322
1323 test_return_t increment_with_initial_test(memcached_st *memc)
1324 {
1325   return __increment_with_initial_test(memc, 0);
1326 }
1327
1328 test_return_t increment_with_initial_999_test(memcached_st *memc)
1329 {
1330   return __increment_with_initial_test(memc, 999);
1331 }
1332
1333 test_return_t decrement_test(memcached_st *memc)
1334 {
1335   test_compare(return_value_based_on_buffering(memc),
1336                memcached_set(memc,
1337                              test_literal_param(__func__),
1338                              test_literal_param("3"),
1339                              time_t(0), uint32_t(0)));
1340
1341   // Make sure we flush the value we just set
1342   test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
1343
1344   uint64_t new_number;
1345   test_compare(MEMCACHED_SUCCESS,
1346                memcached_decrement(memc,
1347                                    test_literal_param(__func__),
1348                                    1, &new_number));
1349   test_compare(uint64_t(2), new_number);
1350
1351   test_compare(MEMCACHED_SUCCESS,
1352                memcached_decrement(memc,
1353                                    test_literal_param(__func__),
1354                                    1, &new_number));
1355   test_compare(uint64_t(1), new_number);
1356
1357   return TEST_SUCCESS;
1358 }
1359
1360 static test_return_t __decrement_with_initial_test(memcached_st *memc, uint64_t initial)
1361 {
1362   test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
1363
1364   test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
1365
1366   uint64_t new_number;
1367   test_compare(MEMCACHED_SUCCESS,
1368                memcached_decrement_with_initial(memc,
1369                                                 test_literal_param(__func__),
1370                                                 1, initial,
1371                                                 0, &new_number));
1372   test_compare(new_number, initial);
1373
1374   test_compare(MEMCACHED_SUCCESS,
1375                memcached_decrement_with_initial(memc,
1376                                                 test_literal_param(__func__),
1377                                                 1, initial,
1378                                                 0, &new_number));
1379   test_compare(new_number, (initial - 1));
1380
1381   return TEST_SUCCESS;
1382 }
1383
1384 test_return_t decrement_with_initial_test(memcached_st *memc)
1385 {
1386   return __decrement_with_initial_test(memc, 3);
1387 }
1388
1389 test_return_t decrement_with_initial_999_test(memcached_st *memc)
1390 {
1391   return __decrement_with_initial_test(memc, 999);
1392 }
1393
1394 test_return_t increment_by_key_test(memcached_st *memc)
1395 {
1396   const char *master_key= "foo";
1397   const char *key= "number";
1398   const char *value= "0";
1399
1400   test_compare(return_value_based_on_buffering(memc),
1401                memcached_set_by_key(memc, master_key, strlen(master_key),
1402                                     key, strlen(key),
1403                                     value, strlen(value),
1404                                     time_t(0), uint32_t(0)));
1405
1406   // Make sure we flush the value we just set
1407   test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
1408
1409   uint64_t new_number;
1410   test_compare(MEMCACHED_SUCCESS,
1411                memcached_increment_by_key(memc, master_key, strlen(master_key),
1412                                           key, strlen(key), 1, &new_number));
1413   test_compare(uint64_t(1), new_number);
1414
1415   test_compare(MEMCACHED_SUCCESS,
1416                memcached_increment_by_key(memc, master_key, strlen(master_key),
1417                                           key, strlen(key), 1, &new_number));
1418   test_compare(uint64_t(2), new_number);
1419
1420   return TEST_SUCCESS;
1421 }
1422
1423 test_return_t increment_with_initial_by_key_test(memcached_st *memc)
1424 {
1425   uint64_t new_number;
1426   const char *master_key= "foo";
1427   const char *key= "number";
1428   uint64_t initial= 0;
1429
1430   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
1431   {
1432     test_compare(MEMCACHED_SUCCESS,
1433                  memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1434                                                          key, strlen(key),
1435                                                          1, initial, 0, &new_number));
1436     test_compare(new_number, initial);
1437
1438     test_compare(MEMCACHED_SUCCESS,
1439                  memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1440                                                          key, strlen(key),
1441                                                          1, initial, 0, &new_number));
1442     test_compare(new_number, (initial +1));
1443   }
1444   else
1445   {
1446     test_compare(MEMCACHED_INVALID_ARGUMENTS,
1447                  memcached_increment_with_initial_by_key(memc, master_key, strlen(master_key),
1448                                                          key, strlen(key),
1449                                                          1, initial, 0, &new_number));
1450   }
1451
1452   return TEST_SUCCESS;
1453 }
1454
1455 test_return_t decrement_by_key_test(memcached_st *memc)
1456 {
1457   uint64_t new_number;
1458   const char *value= "3";
1459
1460   test_compare(return_value_based_on_buffering(memc),
1461                memcached_set_by_key(memc,
1462                                     test_literal_param("foo"),
1463                                     test_literal_param("number"),
1464                                     value, strlen(value),
1465                                     (time_t)0, (uint32_t)0));
1466
1467   test_compare(MEMCACHED_SUCCESS,
1468                memcached_decrement_by_key(memc,
1469                                           test_literal_param("foo"),
1470                                           test_literal_param("number"),
1471                                           1, &new_number));
1472   test_compare(uint64_t(2), new_number);
1473
1474   test_compare(MEMCACHED_SUCCESS,
1475                memcached_decrement_by_key(memc,
1476                                           test_literal_param("foo"),
1477                                           test_literal_param("number"),
1478                                           1, &new_number));
1479   test_compare(uint64_t(1), new_number);
1480
1481   return TEST_SUCCESS;
1482 }
1483
1484 test_return_t decrement_with_initial_by_key_test(memcached_st *memc)
1485 {
1486   test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
1487
1488   uint64_t new_number;
1489   uint64_t initial= 3;
1490
1491   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL))
1492   {
1493     test_compare(MEMCACHED_SUCCESS,
1494                  memcached_decrement_with_initial_by_key(memc,
1495                                                          test_literal_param("foo"),
1496                                                          test_literal_param("number"),
1497                                                          1, initial, 0, &new_number));
1498     test_compare(new_number, initial);
1499
1500     test_compare(MEMCACHED_SUCCESS,
1501                  memcached_decrement_with_initial_by_key(memc,
1502                                                          test_literal_param("foo"),
1503                                                          test_literal_param("number"),
1504                                                          1, initial, 0, &new_number));
1505     test_compare(new_number, (initial - 1));
1506   }
1507   else
1508   {
1509     test_compare(MEMCACHED_INVALID_ARGUMENTS,
1510                  memcached_decrement_with_initial_by_key(memc,
1511                                                          test_literal_param("foo"),
1512                                                          test_literal_param("number"),
1513                                                          1, initial, 0, &new_number));
1514   }
1515
1516   return TEST_SUCCESS;
1517 }
1518 test_return_t binary_increment_with_prefix_test(memcached_st *memc)
1519 {
1520   test_skip(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
1521
1522   test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)"namespace:"));
1523
1524   test_compare(return_value_based_on_buffering(memc),
1525                memcached_set(memc,
1526                              test_literal_param("number"),
1527                              test_literal_param("0"),
1528                              (time_t)0, (uint32_t)0));
1529
1530   uint64_t new_number;
1531   test_compare(MEMCACHED_SUCCESS, memcached_increment(memc,
1532                                                       test_literal_param("number"),
1533                                                       1, &new_number));
1534   test_compare(uint64_t(1), new_number);
1535
1536   test_compare(MEMCACHED_SUCCESS, memcached_increment(memc,
1537                                                       test_literal_param("number"),
1538                                                       1, &new_number));
1539   test_compare(uint64_t(2), new_number);
1540
1541   return TEST_SUCCESS;
1542 }
1543
1544 test_return_t quit_test(memcached_st *memc)
1545 {
1546   const char *value= "sanford and sun";
1547
1548   test_compare(return_value_based_on_buffering(memc),
1549                memcached_set(memc,
1550                              test_literal_param(__func__),
1551                              value, strlen(value),
1552                              time_t(10), uint32_t(3)));
1553   memcached_quit(memc);
1554
1555   test_compare(return_value_based_on_buffering(memc),
1556                memcached_set(memc,
1557                              test_literal_param(__func__),
1558                              value, strlen(value),
1559                              time_t(50), uint32_t(9)));
1560
1561   return TEST_SUCCESS;
1562 }
1563
1564 test_return_t mget_result_test(memcached_st *memc)
1565 {
1566   const char *keys[]= {"fudge", "son", "food"};
1567   size_t key_length[]= {5, 3, 4};
1568
1569   memcached_result_st results_obj;
1570   memcached_result_st *results= memcached_result_create(memc, &results_obj);
1571   test_true(results);
1572   test_true(&results_obj == results);
1573
1574   /* We need to empty the server before continueing test */
1575   test_compare(MEMCACHED_SUCCESS,
1576                memcached_flush(memc, 0));
1577
1578   test_compare(MEMCACHED_SUCCESS,
1579                memcached_mget(memc, keys, key_length, 3));
1580
1581   memcached_return_t rc;
1582   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1583   {
1584     test_true(results);
1585   }
1586
1587   while ((results= memcached_fetch_result(memc, &results_obj, &rc))) { test_true(false); /* We should never see a value returned */ };
1588   test_false(results);
1589   test_compare(MEMCACHED_NOTFOUND, rc);
1590
1591   for (uint32_t x= 0; x < 3; x++)
1592   {
1593     rc= memcached_set(memc, keys[x], key_length[x],
1594                       keys[x], key_length[x],
1595                       (time_t)50, (uint32_t)9);
1596     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1597   }
1598
1599   test_compare(MEMCACHED_SUCCESS,
1600                memcached_mget(memc, keys, key_length, 3));
1601
1602   while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
1603   {
1604     test_true(results);
1605     test_true(&results_obj == results);
1606     test_compare(MEMCACHED_SUCCESS, rc);
1607     test_memcmp(memcached_result_key_value(results),
1608                 memcached_result_value(results),
1609                 memcached_result_length(results));
1610     test_compare(memcached_result_key_length(results), memcached_result_length(results));
1611   }
1612
1613   memcached_result_free(&results_obj);
1614
1615   return TEST_SUCCESS;
1616 }
1617
1618 test_return_t mget_result_alloc_test(memcached_st *memc)
1619 {
1620   const char *keys[]= {"fudge", "son", "food"};
1621   size_t key_length[]= {5, 3, 4};
1622
1623   memcached_result_st *results;
1624
1625   /* We need to empty the server before continueing test */
1626   test_compare(MEMCACHED_SUCCESS,
1627                memcached_flush(memc, 0));
1628
1629   test_compare(MEMCACHED_SUCCESS,
1630                memcached_mget(memc, keys, key_length, 3));
1631
1632   memcached_return_t rc;
1633   while ((results= memcached_fetch_result(memc, NULL, &rc)))
1634   {
1635     test_true(results);
1636   }
1637   test_false(results);
1638   test_compare(MEMCACHED_NOTFOUND, rc);
1639
1640   for (uint32_t x= 0; x < 3; x++)
1641   {
1642     rc= memcached_set(memc, keys[x], key_length[x],
1643                       keys[x], key_length[x],
1644                       (time_t)50, (uint32_t)9);
1645     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1646   }
1647
1648   test_compare(MEMCACHED_SUCCESS,
1649                memcached_mget(memc, keys, key_length, 3));
1650
1651   uint32_t x= 0;
1652   while ((results= memcached_fetch_result(memc, NULL, &rc)))
1653   {
1654     test_true(results);
1655     test_compare(MEMCACHED_SUCCESS, rc);
1656     test_compare(memcached_result_key_length(results), memcached_result_length(results));
1657     test_memcmp(memcached_result_key_value(results),
1658                 memcached_result_value(results),
1659                 memcached_result_length(results));
1660     memcached_result_free(results);
1661     x++;
1662   }
1663
1664   return TEST_SUCCESS;
1665 }
1666
1667 test_return_t mget_result_function(memcached_st *memc)
1668 {
1669   const char *keys[]= {"fudge", "son", "food"};
1670   size_t key_length[]= {5, 3, 4};
1671   size_t counter;
1672   memcached_execute_fn callbacks[1];
1673
1674   for (uint32_t x= 0; x < 3; x++)
1675   {
1676     test_compare(return_value_based_on_buffering(memc),
1677                  memcached_set(memc, keys[x], key_length[x],
1678                                keys[x], key_length[x],
1679                                time_t(50), uint32_t(9)));
1680   }
1681   test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
1682   memcached_quit(memc);
1683
1684   test_compare(MEMCACHED_SUCCESS,
1685                memcached_mget(memc, keys, key_length, 3));
1686
1687   callbacks[0]= &callback_counter;
1688   counter= 0;
1689
1690   test_compare(MEMCACHED_SUCCESS,
1691                memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
1692
1693   test_compare(size_t(3), counter);
1694
1695   return TEST_SUCCESS;
1696 }
1697
1698 test_return_t mget_test(memcached_st *memc)
1699 {
1700   const char *keys[]= {"fudge", "son", "food"};
1701   size_t key_length[]= {5, 3, 4};
1702
1703   char return_key[MEMCACHED_MAX_KEY];
1704   size_t return_key_length;
1705   char *return_value;
1706   size_t return_value_length;
1707
1708   test_compare(MEMCACHED_SUCCESS,
1709                memcached_mget(memc, keys, key_length, 3));
1710
1711   uint32_t flags;
1712   memcached_return_t rc;
1713   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1714                                         &return_value_length, &flags, &rc)))
1715   {
1716     test_true(return_value);
1717   }
1718   test_false(return_value);
1719   test_zero(return_value_length);
1720   test_compare(MEMCACHED_NOTFOUND, rc);
1721
1722   for (uint32_t x= 0; x < 3; x++)
1723   {
1724     rc= memcached_set(memc, keys[x], key_length[x],
1725                       keys[x], key_length[x],
1726                       (time_t)50, (uint32_t)9);
1727     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1728   }
1729   test_compare(MEMCACHED_SUCCESS,
1730                memcached_mget(memc, keys, key_length, 3));
1731
1732   uint32_t x= 0;
1733   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
1734                                         &return_value_length, &flags, &rc)))
1735   {
1736     test_true(return_value);
1737     test_compare(MEMCACHED_SUCCESS, rc);
1738     if (not memc->_namespace)
1739     {
1740       test_compare(return_key_length, return_value_length);
1741       test_memcmp(return_value, return_key, return_value_length);
1742     }
1743     free(return_value);
1744     x++;
1745   }
1746
1747   return TEST_SUCCESS;
1748 }
1749
1750 test_return_t mget_execute(memcached_st *original_memc)
1751 {
1752   test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
1753
1754   memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
1755   test_true(memc);
1756
1757   keys_st keys(20480);
1758
1759   /* First add all of the items.. */
1760   char blob[1024] = {0};
1761
1762   for (size_t x= 0; x < keys.size(); ++x)
1763   {
1764     uint64_t query_id= memcached_query_id(memc);
1765     memcached_return_t rc= memcached_add(memc,
1766                                          keys.key_at(x), keys.length_at(x),
1767                                          blob, sizeof(blob),
1768                                          0, 0);
1769     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1770     test_compare(query_id +1, memcached_query_id(memc));
1771   }
1772
1773   /* Try to get all of them with a large multiget */
1774   size_t counter= 0;
1775   memcached_execute_fn callbacks[]= { &callback_counter };
1776   test_compare(MEMCACHED_SUCCESS,
1777                memcached_mget_execute(memc,
1778                                       keys.keys_ptr(), keys.lengths_ptr(),
1779                                       keys.size(), callbacks, &counter, 1));
1780
1781   {
1782     uint64_t query_id= memcached_query_id(memc);
1783     test_compare(MEMCACHED_SUCCESS,
1784                  memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
1785     test_compare(query_id, memcached_query_id(memc));
1786
1787     /* Verify that we got all of the items */
1788     test_compare(keys.size(), counter);
1789   }
1790
1791   memcached_free(memc);
1792
1793   return TEST_SUCCESS;
1794 }
1795
1796 test_return_t MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH_TEST(memcached_st *original_memc)
1797 {
1798   test_skip(true, memcached_behavior_get(original_memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL));
1799
1800   memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
1801   test_true(memc);
1802
1803   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 8));
1804
1805   keys_st keys(20480);
1806
1807   /* First add all of the items.. */
1808   char blob[1024] = {0};
1809
1810   for (size_t x= 0; x < keys.size(); ++x)
1811   {
1812     uint64_t query_id= memcached_query_id(memc);
1813     memcached_return_t rc= memcached_add(memc,
1814                                          keys.key_at(x), keys.length_at(x),
1815                                          blob, sizeof(blob),
1816                                          0, 0);
1817     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
1818     test_compare(query_id +1, memcached_query_id(memc));
1819   }
1820
1821   /* Try to get all of them with a large multiget */
1822   size_t counter= 0;
1823   memcached_execute_fn callbacks[]= { &callback_counter };
1824   test_compare(MEMCACHED_SUCCESS,
1825                memcached_mget_execute(memc,
1826                                       keys.keys_ptr(), keys.lengths_ptr(),
1827                                       keys.size(), callbacks, &counter, 1));
1828
1829   {
1830     uint64_t query_id= memcached_query_id(memc);
1831     test_compare(MEMCACHED_SUCCESS,
1832                  memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
1833     test_compare(query_id, memcached_query_id(memc));
1834
1835     /* Verify that we got all of the items */
1836     test_compare(keys.size(), counter);
1837   }
1838
1839   memcached_free(memc);
1840
1841   return TEST_SUCCESS;
1842 }
1843
1844 #define REGRESSION_BINARY_VS_BLOCK_COUNT  20480
1845 static pairs_st *global_pairs= NULL;
1846
1847 test_return_t key_setup(memcached_st *memc)
1848 {
1849   test_skip(TEST_SUCCESS, pre_binary(memc));
1850
1851   global_pairs= pairs_generate(REGRESSION_BINARY_VS_BLOCK_COUNT, 0);
1852
1853   return TEST_SUCCESS;
1854 }
1855
1856 test_return_t key_teardown(memcached_st *)
1857 {
1858   pairs_free(global_pairs);
1859   global_pairs= NULL;
1860
1861   return TEST_SUCCESS;
1862 }
1863
1864 test_return_t block_add_regression(memcached_st *memc)
1865 {
1866   /* First add all of the items.. */
1867   for (ptrdiff_t x= 0; x < REGRESSION_BINARY_VS_BLOCK_COUNT; ++x)
1868   {
1869     libtest::vchar_t blob;
1870     libtest::vchar::make(blob, 1024);
1871
1872     memcached_return_t rc= memcached_add_by_key(memc,
1873                                                 test_literal_param("bob"),
1874                                                 global_pairs[x].key, global_pairs[x].key_length,
1875                                                 &blob[0], blob.size(),
1876                                                 time_t(0), uint32_t(0));
1877     if (rc == MEMCACHED_MEMORY_ALLOCATION_FAILURE)
1878     {
1879       Error << memcached_last_error_message(memc);
1880       return TEST_SKIPPED;
1881     }
1882     test_compare(*memc, MEMCACHED_SUCCESS);
1883     test_compare(rc, MEMCACHED_SUCCESS);
1884   }
1885
1886   return TEST_SUCCESS;
1887 }
1888
1889 test_return_t binary_add_regression(memcached_st *memc)
1890 {
1891   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
1892   return block_add_regression(memc);
1893 }
1894
1895 test_return_t get_stats_keys(memcached_st *memc)
1896 {
1897  char **stat_list;
1898  char **ptr;
1899  memcached_stat_st memc_stat;
1900  memcached_return_t rc;
1901
1902  stat_list= memcached_stat_get_keys(memc, &memc_stat, &rc);
1903  test_compare(MEMCACHED_SUCCESS, rc);
1904  for (ptr= stat_list; *ptr; ptr++)
1905    test_true(*ptr);
1906
1907  free(stat_list);
1908
1909  return TEST_SUCCESS;
1910 }
1911
1912 test_return_t version_string_test(memcached_st *)
1913 {
1914   test_strcmp(LIBMEMCACHED_VERSION_STRING, memcached_lib_version());
1915
1916   return TEST_SUCCESS;
1917 }
1918
1919 test_return_t get_stats(memcached_st *memc)
1920 {
1921  memcached_return_t rc;
1922
1923  memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
1924  test_compare(MEMCACHED_SUCCESS, rc);
1925  test_true(memc_stat);
1926
1927  for (uint32_t x= 0; x < memcached_server_count(memc); x++)
1928  {
1929    char **stat_list= memcached_stat_get_keys(memc, memc_stat+x, &rc);
1930    test_compare(MEMCACHED_SUCCESS, rc);
1931    for (char **ptr= stat_list; *ptr; ptr++) {};
1932
1933    free(stat_list);
1934  }
1935
1936  memcached_stat_free(NULL, memc_stat);
1937
1938   return TEST_SUCCESS;
1939 }
1940
1941 test_return_t add_host_test(memcached_st *memc)
1942 {
1943   char servername[]= "0.example.com";
1944
1945   memcached_return_t rc;
1946   memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
1947   test_compare(1U, memcached_server_list_count(servers));
1948
1949   for (unsigned int x= 2; x < 20; x++)
1950   {
1951     char buffer[SMALL_STRING_LEN];
1952
1953     snprintf(buffer, SMALL_STRING_LEN, "%u.example.com", 400+x);
1954     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
1955                                      &rc);
1956     test_compare(MEMCACHED_SUCCESS, rc);
1957     test_compare(x, memcached_server_list_count(servers));
1958   }
1959
1960   test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
1961   test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
1962
1963   memcached_server_list_free(servers);
1964
1965   return TEST_SUCCESS;
1966 }
1967
1968 test_return_t regression_1048945_TEST(memcached_st*)
1969 {
1970   memcached_return status;
1971
1972   memcached_server_st* list= memcached_server_list_append_with_weight(NULL, "a", 11211, 0, &status);
1973   test_compare(status, MEMCACHED_SUCCESS);
1974
1975   list= memcached_server_list_append_with_weight(list, "b", 11211, 0, &status);
1976   test_compare(status, MEMCACHED_SUCCESS);
1977
1978   list= memcached_server_list_append_with_weight(list, "c", 11211, 0, &status);
1979   test_compare(status, MEMCACHED_SUCCESS);
1980
1981   memcached_st* memc= memcached_create(NULL);
1982
1983   status= memcached_server_push(memc, list);
1984   memcached_server_list_free(list);
1985   test_compare(status, MEMCACHED_SUCCESS);
1986
1987   const memcached_instance_st * server= memcached_server_by_key(memc, test_literal_param(__func__), &status);
1988   test_true(server);
1989   test_compare(status, MEMCACHED_SUCCESS);
1990
1991   memcached_free(memc);
1992
1993   return TEST_SUCCESS;
1994 }
1995
1996 test_return_t memcached_fetch_result_NOT_FOUND(memcached_st *memc)
1997 {
1998   memcached_return_t rc;
1999
2000   const char *key= "not_found";
2001   size_t key_length= test_literal_param_size("not_found");
2002
2003   test_compare(MEMCACHED_SUCCESS,
2004                memcached_mget(memc, &key, &key_length, 1));
2005
2006   memcached_result_st *result= memcached_fetch_result(memc, NULL, &rc);
2007   test_null(result);
2008   test_compare(MEMCACHED_NOTFOUND, rc);
2009
2010   memcached_result_free(result);
2011
2012   return TEST_SUCCESS;
2013 }
2014
2015 static memcached_return_t  clone_test_callback(memcached_st *, memcached_st *)
2016 {
2017   return MEMCACHED_SUCCESS;
2018 }
2019
2020 static memcached_return_t  cleanup_test_callback(memcached_st *)
2021 {
2022   return MEMCACHED_SUCCESS;
2023 }
2024
2025 test_return_t callback_test(memcached_st *memc)
2026 {
2027   /* Test User Data */
2028   {
2029     int x= 5;
2030     int *test_ptr;
2031     memcached_return_t rc;
2032
2033     test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_USER_DATA, &x));
2034     test_ptr= (int *)memcached_callback_get(memc, MEMCACHED_CALLBACK_USER_DATA, &rc);
2035     test_true(*test_ptr == x);
2036   }
2037
2038   /* Test Clone Callback */
2039   {
2040     memcached_clone_fn clone_cb= (memcached_clone_fn)clone_test_callback;
2041     void *clone_cb_ptr= *(void **)&clone_cb;
2042     void *temp_function= NULL;
2043
2044     test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, clone_cb_ptr));
2045     memcached_return_t rc;
2046     temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
2047     test_true(temp_function == clone_cb_ptr);
2048     test_compare(MEMCACHED_SUCCESS, rc);
2049   }
2050
2051   /* Test Cleanup Callback */
2052   {
2053     memcached_cleanup_fn cleanup_cb= (memcached_cleanup_fn)cleanup_test_callback;
2054     void *cleanup_cb_ptr= *(void **)&cleanup_cb;
2055     void *temp_function= NULL;
2056     memcached_return_t rc;
2057
2058     test_compare(MEMCACHED_SUCCESS, memcached_callback_set(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, cleanup_cb_ptr));
2059     temp_function= memcached_callback_get(memc, MEMCACHED_CALLBACK_CLONE_FUNCTION, &rc);
2060     test_true(temp_function == cleanup_cb_ptr);
2061   }
2062
2063   return TEST_SUCCESS;
2064 }
2065
2066 /* We don't test the behavior itself, we test the switches */
2067 test_return_t behavior_test(memcached_st *memc)
2068 {
2069   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
2070   test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
2071
2072   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
2073   test_compare(true, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
2074
2075   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_MD5);
2076   test_compare(uint64_t(MEMCACHED_HASH_MD5), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
2077
2078   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
2079   test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NO_BLOCK));
2080
2081   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
2082   test_zero(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY));
2083
2084   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_DEFAULT);
2085   test_compare(uint64_t(MEMCACHED_HASH_DEFAULT), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
2086
2087   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, MEMCACHED_HASH_CRC);
2088   test_compare(uint64_t(MEMCACHED_HASH_CRC), memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH));
2089
2090   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_SEND_SIZE));
2091
2092   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SOCKET_RECV_SIZE));
2093
2094   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS);
2095   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, value +1);
2096   test_compare((value +1),  memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS));
2097
2098   return TEST_SUCCESS;
2099 }
2100
2101 test_return_t MEMCACHED_BEHAVIOR_CORK_test(memcached_st *memc)
2102 {
2103   test_compare(MEMCACHED_DEPRECATED,
2104                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, true));
2105
2106   // Platform dependent
2107 #if 0
2108   bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_CORK);
2109   test_false(value);
2110 #endif
2111
2112   return TEST_SUCCESS;
2113 }
2114
2115
2116 test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test(memcached_st *memc)
2117 {
2118   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE, true);
2119   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
2120
2121   bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPALIVE);
2122
2123   if (memcached_success(rc))
2124   {
2125     test_true(value);
2126   }
2127   else
2128   {
2129     test_false(value);
2130   }
2131
2132   return TEST_SUCCESS;
2133 }
2134
2135
2136 test_return_t MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test(memcached_st *memc)
2137 {
2138   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE, true);
2139   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_NOT_SUPPORTED);
2140
2141   bool value= (bool)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_TCP_KEEPIDLE);
2142
2143   if (memcached_success(rc))
2144   {
2145     test_true(value);
2146   }
2147   else
2148   {
2149     test_false(value);
2150   }
2151
2152   return TEST_SUCCESS;
2153 }
2154
2155 /* Make sure we behave properly if server list has no values */
2156 test_return_t user_supplied_bug4(memcached_st *memc)
2157 {
2158   const char *keys[]= {"fudge", "son", "food"};
2159   size_t key_length[]= {5, 3, 4};
2160
2161   /* Here we free everything before running a bunch of mget tests */
2162   memcached_servers_reset(memc);
2163
2164
2165   /* We need to empty the server before continueing test */
2166   test_compare(MEMCACHED_NO_SERVERS,
2167                memcached_flush(memc, 0));
2168
2169   test_compare(MEMCACHED_NO_SERVERS,
2170                memcached_mget(memc, keys, key_length, 3));
2171
2172   {
2173     unsigned int keys_returned;
2174     memcached_return_t rc;
2175     test_compare(TEST_SUCCESS, fetch_all_results(memc, keys_returned, rc));
2176     test_compare(MEMCACHED_NOTFOUND, rc);
2177     test_zero(keys_returned);
2178   }
2179
2180   for (uint32_t x= 0; x < 3; x++)
2181   {
2182     test_compare(MEMCACHED_NO_SERVERS,
2183                  memcached_set(memc, keys[x], key_length[x],
2184                                keys[x], key_length[x],
2185                                (time_t)50, (uint32_t)9));
2186   }
2187
2188   test_compare(MEMCACHED_NO_SERVERS,
2189                memcached_mget(memc, keys, key_length, 3));
2190
2191   {
2192     char *return_value;
2193     char return_key[MEMCACHED_MAX_KEY];
2194     memcached_return_t rc;
2195     size_t return_key_length;
2196     size_t return_value_length;
2197     uint32_t flags;
2198     uint32_t x= 0;
2199     while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2200                                           &return_value_length, &flags, &rc)))
2201     {
2202       test_true(return_value);
2203       test_compare(MEMCACHED_SUCCESS, rc);
2204       test_true(return_key_length == return_value_length);
2205       test_memcmp(return_value, return_key, return_value_length);
2206       free(return_value);
2207       x++;
2208     }
2209   }
2210
2211   return TEST_SUCCESS;
2212 }
2213
2214 #define VALUE_SIZE_BUG5 1048064
2215 test_return_t user_supplied_bug5(memcached_st *memc)
2216 {
2217   const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2218   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2219   char *value;
2220   size_t value_length;
2221   uint32_t flags;
2222   char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2223
2224   for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
2225   {
2226     insert_data[x]= (signed char)rand();
2227   }
2228
2229   test_compare(MEMCACHED_SUCCESS,
2230                memcached_flush(memc, 0));
2231
2232   memcached_return_t rc;
2233   test_null(memcached_get(memc, keys[0], key_length[0], &value_length, &flags, &rc));
2234   test_compare(MEMCACHED_SUCCESS,
2235                memcached_mget(memc, keys, key_length, 4));
2236
2237   unsigned int count;
2238   test_compare(TEST_SUCCESS, fetch_all_results(memc, count, rc));
2239   test_compare(MEMCACHED_NOTFOUND, rc);
2240   test_zero(count);
2241
2242   for (uint32_t x= 0; x < 4; x++)
2243   {
2244     test_compare(MEMCACHED_SUCCESS,
2245                  memcached_set(memc, keys[x], key_length[x],
2246                                insert_data, VALUE_SIZE_BUG5,
2247                                (time_t)0, (uint32_t)0));
2248   }
2249
2250   for (uint32_t x= 0; x < 10; x++)
2251   {
2252     value= memcached_get(memc, keys[0], key_length[0],
2253                          &value_length, &flags, &rc);
2254     test_compare(rc, MEMCACHED_SUCCESS);
2255     test_true(value);
2256     ::free(value);
2257
2258     test_compare(MEMCACHED_SUCCESS,
2259                  memcached_mget(memc, keys, key_length, 4));
2260
2261     test_compare(TEST_SUCCESS, fetch_all_results(memc, count));
2262     test_compare(4U, count);
2263   }
2264   delete [] insert_data;
2265
2266   return TEST_SUCCESS;
2267 }
2268
2269 test_return_t user_supplied_bug6(memcached_st *memc)
2270 {
2271   const char *keys[]= {"036790384900", "036790384902", "036790384904", "036790384906"};
2272   size_t key_length[]=  {strlen("036790384900"), strlen("036790384902"), strlen("036790384904"), strlen("036790384906")};
2273   char return_key[MEMCACHED_MAX_KEY];
2274   size_t return_key_length;
2275   char *value;
2276   size_t value_length;
2277   uint32_t flags;
2278   char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2279
2280   for (uint32_t x= 0; x < VALUE_SIZE_BUG5; x++)
2281   {
2282     insert_data[x]= (signed char)rand();
2283   }
2284
2285   test_compare(MEMCACHED_SUCCESS, memcached_flush(memc, 0));
2286
2287   test_compare(TEST_SUCCESS, confirm_keys_dont_exist(memc, keys, test_array_length(keys)));
2288
2289   // We will now confirm that memcached_mget() returns success, but we will
2290   // then check to make sure that no actual keys are returned.
2291   test_compare(MEMCACHED_SUCCESS,
2292                memcached_mget(memc, keys, key_length, 4));
2293
2294   memcached_return_t rc;
2295   uint32_t count= 0;
2296   while ((value= memcached_fetch(memc, return_key, &return_key_length,
2297                                  &value_length, &flags, &rc)))
2298   {
2299     count++;
2300   }
2301   test_zero(count);
2302   test_compare(MEMCACHED_NOTFOUND, rc);
2303
2304   for (uint32_t x= 0; x < test_array_length(keys); x++)
2305   {
2306     test_compare(MEMCACHED_SUCCESS,
2307                  memcached_set(memc, keys[x], key_length[x],
2308                                insert_data, VALUE_SIZE_BUG5,
2309                                (time_t)0, (uint32_t)0));
2310   }
2311   test_compare(TEST_SUCCESS, confirm_keys_exist(memc, keys, test_array_length(keys)));
2312
2313   for (uint32_t x= 0; x < 2; x++)
2314   {
2315     value= memcached_get(memc, keys[0], key_length[0],
2316                          &value_length, &flags, &rc);
2317     test_true(value);
2318     free(value);
2319
2320     test_compare(MEMCACHED_SUCCESS,
2321                  memcached_mget(memc, keys, key_length, 4));
2322     /* We test for purge of partial complete fetches */
2323     for (count= 3; count; count--)
2324     {
2325       value= memcached_fetch(memc, return_key, &return_key_length,
2326                              &value_length, &flags, &rc);
2327       test_compare(MEMCACHED_SUCCESS, rc);
2328       test_memcmp(value, insert_data, value_length);
2329       test_true(value_length);
2330       free(value);
2331     }
2332   }
2333   delete [] insert_data;
2334
2335   return TEST_SUCCESS;
2336 }
2337
2338 test_return_t user_supplied_bug8(memcached_st *)
2339 {
2340   memcached_return_t rc;
2341   memcached_st *mine;
2342   memcached_st *memc_clone;
2343
2344   memcached_server_st *servers;
2345   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";
2346
2347   servers= memcached_servers_parse(server_list);
2348   test_true(servers);
2349
2350   mine= memcached_create(NULL);
2351   rc= memcached_server_push(mine, servers);
2352   test_compare(MEMCACHED_SUCCESS, rc);
2353   memcached_server_list_free(servers);
2354
2355   test_true(mine);
2356   memc_clone= memcached_clone(NULL, mine);
2357
2358   memcached_quit(mine);
2359   memcached_quit(memc_clone);
2360
2361
2362   memcached_free(mine);
2363   memcached_free(memc_clone);
2364
2365   return TEST_SUCCESS;
2366 }
2367
2368 /* Test flag store/retrieve */
2369 test_return_t user_supplied_bug7(memcached_st *memc)
2370 {
2371   char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2372   test_true(insert_data);
2373
2374   for (size_t x= 0; x < VALUE_SIZE_BUG5; x++)
2375   {
2376     insert_data[x]= (signed char)rand();
2377   }
2378
2379   memcached_flush(memc, 0);
2380
2381   const char *keys= "036790384900";
2382   size_t key_length=  strlen(keys);
2383   test_compare(MEMCACHED_SUCCESS, memcached_set(memc, keys, key_length,
2384                                                 insert_data, VALUE_SIZE_BUG5,
2385                                                 time_t(0), 245U));
2386
2387   memcached_return_t rc;
2388   size_t value_length;
2389   uint32_t flags= 0;
2390   char *value= memcached_get(memc, keys, key_length,
2391                              &value_length, &flags, &rc);
2392   test_compare(245U, flags);
2393   test_true(value);
2394   free(value);
2395
2396   test_compare(MEMCACHED_SUCCESS, memcached_mget(memc, &keys, &key_length, 1));
2397
2398   char return_key[MEMCACHED_MAX_KEY];
2399   size_t return_key_length;
2400   flags= 0;
2401   value= memcached_fetch(memc, return_key, &return_key_length,
2402                          &value_length, &flags, &rc);
2403   test_compare(uint32_t(245), flags);
2404   test_true(value);
2405   free(value);
2406   delete [] insert_data;
2407
2408
2409   return TEST_SUCCESS;
2410 }
2411
2412 test_return_t user_supplied_bug9(memcached_st *memc)
2413 {
2414   const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2415   size_t key_length[3];
2416   uint32_t flags;
2417   unsigned count= 0;
2418
2419   char return_key[MEMCACHED_MAX_KEY];
2420   size_t return_key_length;
2421   char *return_value;
2422   size_t return_value_length;
2423
2424
2425   key_length[0]= strlen("UDATA:edevil@sapo.pt");
2426   key_length[1]= strlen("fudge&*@#");
2427   key_length[2]= strlen("for^#@&$not");
2428
2429
2430   for (unsigned int x= 0; x < 3; x++)
2431   {
2432     memcached_return_t rc= memcached_set(memc, keys[x], key_length[x],
2433                                          keys[x], key_length[x],
2434                                          (time_t)50, (uint32_t)9);
2435     test_compare(MEMCACHED_SUCCESS, rc);
2436   }
2437
2438   memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
2439   test_compare(MEMCACHED_SUCCESS, rc);
2440
2441   /* We need to empty the server before continueing test */
2442   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2443                                         &return_value_length, &flags, &rc)) != NULL)
2444   {
2445     test_true(return_value);
2446     free(return_value);
2447     count++;
2448   }
2449   test_compare(3U, count);
2450
2451   return TEST_SUCCESS;
2452 }
2453
2454 /* We are testing with aggressive timeout to get failures */
2455 test_return_t user_supplied_bug10(memcached_st *memc)
2456 {
2457   test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
2458
2459   size_t value_length= 512;
2460   unsigned int set= 1;
2461   memcached_st *mclone= memcached_clone(NULL, memc);
2462
2463   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2464   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2465   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, uint64_t(0));
2466
2467   libtest::vchar_t value;
2468   value.reserve(value_length);
2469   for (uint32_t x= 0; x < value_length; x++)
2470   {
2471     value.push_back(char(x % 127));
2472   }
2473
2474   for (unsigned int x= 1; x <= 100000; ++x)
2475   {
2476     memcached_return_t rc= memcached_set(mclone,
2477                                          test_literal_param("foo"),
2478                                          &value[0], value.size(),
2479                                          0, 0);
2480
2481     test_true((rc == MEMCACHED_SUCCESS or rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_BUFFERED or rc == MEMCACHED_TIMEOUT or rc == MEMCACHED_CONNECTION_FAILURE
2482                or rc == MEMCACHED_SERVER_TEMPORARILY_DISABLED));
2483
2484     if (rc == MEMCACHED_WRITE_FAILURE or rc == MEMCACHED_TIMEOUT)
2485     {
2486       x--;
2487     }
2488   }
2489
2490   memcached_free(mclone);
2491
2492   return TEST_SUCCESS;
2493 }
2494
2495 /*
2496   We are looking failures in the async protocol
2497 */
2498 test_return_t user_supplied_bug11(memcached_st *memc)
2499 {
2500   memcached_st *mclone= memcached_clone(NULL, memc);
2501
2502   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, true);
2503   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
2504   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, size_t(-1));
2505
2506   test_compare(-1, int32_t(memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT)));
2507
2508
2509   libtest::vchar_t value;
2510   value.reserve(512);
2511   for (unsigned int x= 0; x < 512; x++)
2512   {
2513     value.push_back(char(x % 127));
2514   }
2515
2516   for (unsigned int x= 1; x <= 100000; ++x)
2517   {
2518     memcached_return_t rc= memcached_set(mclone, test_literal_param("foo"), &value[0], value.size(), 0, 0);
2519     (void)rc;
2520   }
2521
2522   memcached_free(mclone);
2523
2524   return TEST_SUCCESS;
2525 }
2526
2527 /*
2528   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2529 */
2530 test_return_t user_supplied_bug12(memcached_st *memc)
2531 {
2532   memcached_return_t rc;
2533   uint32_t flags;
2534   size_t value_length;
2535   char *value;
2536   uint64_t number_value;
2537
2538   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2539                        &value_length, &flags, &rc);
2540   test_null(value);
2541   test_compare(MEMCACHED_NOTFOUND, rc);
2542
2543   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2544                           1, &number_value);
2545   test_null(value);
2546   /* The binary protocol will set the key if it doesn't exist */
2547   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2548   {
2549     test_compare(MEMCACHED_SUCCESS, rc);
2550   }
2551   else
2552   {
2553     test_compare(MEMCACHED_NOTFOUND, rc);
2554   }
2555
2556   test_compare(MEMCACHED_SUCCESS,
2557                memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0));
2558
2559   value= memcached_get(memc, "autoincrement", strlen("autoincrement"), &value_length, &flags, &rc);
2560   test_true(value);
2561   free(value);
2562
2563   test_compare(MEMCACHED_SUCCESS,
2564                memcached_increment(memc, "autoincrement", strlen("autoincrement"), 1, &number_value));
2565   test_compare(2UL, number_value);
2566
2567   return TEST_SUCCESS;
2568 }
2569
2570 /*
2571   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2572   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2573 */
2574 test_return_t user_supplied_bug13(memcached_st *memc)
2575 {
2576   char key[] = "key34567890";
2577
2578   char commandFirst[]= "set key34567890 0 0 ";
2579   char commandLast[] = " \r\n"; /* first line of command sent to server */
2580   size_t commandLength;
2581
2582   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2583
2584   size_t overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2585
2586   for (size_t testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2587   {
2588     char *overflow= new (std::nothrow) char[testSize];
2589     test_true(overflow);
2590
2591     memset(overflow, 'x', testSize);
2592     test_compare(MEMCACHED_SUCCESS,
2593                  memcached_set(memc, key, strlen(key),
2594                                overflow, testSize, 0, 0));
2595     delete [] overflow;
2596   }
2597
2598   return TEST_SUCCESS;
2599 }
2600
2601
2602 /*
2603   Test values of many different sizes
2604   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2605   set key34567890 0 0 8169 \r\n
2606   is sent followed by buffer of size 8169, followed by 8169
2607 */
2608 test_return_t user_supplied_bug14(memcached_st *memc)
2609 {
2610   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true);
2611
2612   libtest::vchar_t value;
2613   value.reserve(18000);
2614   for (ptrdiff_t x= 0; x < 18000; x++)
2615   {
2616     value.push_back((char) (x % 127));
2617   }
2618
2619   for (size_t current_length= 1; current_length < value.size(); current_length++)
2620   {
2621     memcached_return_t rc= memcached_set(memc, test_literal_param("foo"),
2622                                          &value[0], current_length,
2623                                          (time_t)0, (uint32_t)0);
2624     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
2625
2626     size_t string_length;
2627     uint32_t flags;
2628     char *string= memcached_get(memc, test_literal_param("foo"),
2629                                 &string_length, &flags, &rc);
2630
2631     test_compare(MEMCACHED_SUCCESS, rc);
2632     test_compare(string_length, current_length);
2633     char buffer[1024];
2634     snprintf(buffer, sizeof(buffer), "%u", uint32_t(string_length));
2635     test_memcmp(string, &value[0], string_length);
2636
2637     free(string);
2638   }
2639
2640   return TEST_SUCCESS;
2641 }
2642
2643 /*
2644   Look for zero length value problems
2645 */
2646 test_return_t user_supplied_bug15(memcached_st *memc)
2647 {
2648   for (uint32_t x= 0; x < 2; x++)
2649   {
2650     memcached_return_t rc= memcached_set(memc, test_literal_param("mykey"),
2651                                          NULL, 0,
2652                                          (time_t)0, (uint32_t)0);
2653
2654     test_compare(MEMCACHED_SUCCESS, rc);
2655
2656     size_t length;
2657     uint32_t flags;
2658     char *value= memcached_get(memc, test_literal_param("mykey"),
2659                                &length, &flags, &rc);
2660
2661     test_compare(MEMCACHED_SUCCESS, rc);
2662     test_false(value);
2663     test_zero(length);
2664     test_zero(flags);
2665
2666     value= memcached_get(memc, test_literal_param("mykey"),
2667                          &length, &flags, &rc);
2668
2669     test_compare(MEMCACHED_SUCCESS, rc);
2670     test_null(value);
2671     test_zero(length);
2672     test_zero(flags);
2673   }
2674
2675   return TEST_SUCCESS;
2676 }
2677
2678 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2679 test_return_t user_supplied_bug16(memcached_st *memc)
2680 {
2681   test_compare(MEMCACHED_SUCCESS, memcached_set(memc, test_literal_param("mykey"),
2682                                                 NULL, 0,
2683                                                 (time_t)0, UINT32_MAX));
2684
2685
2686   size_t length;
2687   uint32_t flags;
2688   memcached_return_t rc;
2689   char *value= memcached_get(memc, test_literal_param("mykey"),
2690                              &length, &flags, &rc);
2691
2692   test_compare(MEMCACHED_SUCCESS, rc);
2693   test_null(value);
2694   test_zero(length);
2695   test_compare(flags, UINT32_MAX);
2696
2697   return TEST_SUCCESS;
2698 }
2699
2700 #if !defined(__sun) && !defined(__OpenBSD__)
2701 /* Check the validity of chinese key*/
2702 test_return_t user_supplied_bug17(memcached_st *memc)
2703 {
2704   const char *key= "豆瓣";
2705   const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2706   memcached_return_t rc= memcached_set(memc, key, strlen(key),
2707                                        value, strlen(value),
2708                                        (time_t)0, 0);
2709
2710   test_compare(MEMCACHED_SUCCESS, rc);
2711
2712   size_t length;
2713   uint32_t flags;
2714   char *value2= memcached_get(memc, key, strlen(key),
2715                               &length, &flags, &rc);
2716
2717   test_compare(length, strlen(value));
2718   test_compare(MEMCACHED_SUCCESS, rc);
2719   test_memcmp(value, value2, length);
2720   free(value2);
2721
2722   return TEST_SUCCESS;
2723 }
2724 #endif
2725
2726 /*
2727   From Andrei on IRC
2728 */
2729
2730 test_return_t user_supplied_bug19(memcached_st *)
2731 {
2732   memcached_return_t res;
2733
2734   memcached_st *memc= memcached(test_literal_param("--server=localhost:11311/?100 --server=localhost:11312/?100"));
2735
2736   const memcached_instance_st * server= memcached_server_by_key(memc, "a", 1, &res);
2737   test_true(server);
2738
2739   memcached_free(memc);
2740
2741   return TEST_SUCCESS;
2742 }
2743
2744 /* CAS test from Andei */
2745 test_return_t user_supplied_bug20(memcached_st *memc)
2746 {
2747   const char *key= "abc";
2748   size_t key_len= strlen("abc");
2749
2750   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
2751
2752   test_compare(MEMCACHED_SUCCESS,
2753                memcached_set(memc,
2754                              test_literal_param("abc"),
2755                              test_literal_param("foobar"),
2756                              (time_t)0, (uint32_t)0));
2757
2758   test_compare(MEMCACHED_SUCCESS,
2759                memcached_mget(memc, &key, &key_len, 1));
2760
2761   memcached_result_st result_obj;
2762   memcached_result_st *result= memcached_result_create(memc, &result_obj);
2763   test_true(result);
2764
2765   memcached_result_create(memc, &result_obj);
2766   memcached_return_t status;
2767   result= memcached_fetch_result(memc, &result_obj, &status);
2768
2769   test_true(result);
2770   test_compare(MEMCACHED_SUCCESS, status);
2771
2772   memcached_result_free(result);
2773
2774   return TEST_SUCCESS;
2775 }
2776
2777 /* Large mget() of missing keys with binary proto
2778  *
2779  * If many binary quiet commands (such as getq's in an mget) fill the output
2780  * buffer and the server chooses not to respond, memcached_flush hangs. See
2781  * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
2782  */
2783
2784 /* sighandler_t function that always asserts false */
2785 static __attribute__((noreturn)) void fail(int)
2786 {
2787   fatal_assert(0);
2788 }
2789
2790
2791 test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
2792 {
2793 #ifdef WIN32
2794   (void)memc;
2795   (void)key_count;
2796   return TEST_SKIPPED;
2797 #else
2798   void (*oldalarm)(int);
2799
2800   memcached_st *memc_clone= memcached_clone(NULL, memc);
2801   test_true(memc_clone);
2802
2803   /* only binproto uses getq for mget */
2804   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, true));
2805
2806   /* empty the cache to ensure misses (hence non-responses) */
2807   test_compare(MEMCACHED_SUCCESS, memcached_flush(memc_clone, 0));
2808
2809   keys_st keys(key_count);
2810
2811   oldalarm= signal(SIGALRM, fail);
2812   alarm(5);
2813
2814   test_compare_got(MEMCACHED_SUCCESS,
2815                    memcached_mget(memc_clone, keys.keys_ptr(), keys.lengths_ptr(), keys.size()),
2816                    memcached_last_error_message(memc_clone));
2817
2818   alarm(0);
2819   signal(SIGALRM, oldalarm);
2820
2821   memcached_return_t rc;
2822   uint32_t flags;
2823   char return_key[MEMCACHED_MAX_KEY];
2824   size_t return_key_length;
2825   char *return_value;
2826   size_t return_value_length;
2827   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2828                                         &return_value_length, &flags, &rc)))
2829   {
2830     test_false(return_value); // There are no keys to fetch, so the value should never be returned
2831   }
2832   test_compare(MEMCACHED_NOTFOUND, rc);
2833   test_zero(return_value_length);
2834   test_zero(return_key_length);
2835   test_false(return_key[0]);
2836   test_false(return_value);
2837
2838   memcached_free(memc_clone);
2839
2840   return TEST_SUCCESS;
2841 #endif
2842 }
2843
2844 test_return_t user_supplied_bug21(memcached_st *memc)
2845 {
2846   test_skip(TEST_SUCCESS, pre_binary(memc));
2847
2848   /* should work as of r580 */
2849   test_compare(TEST_SUCCESS,
2850                _user_supplied_bug21(memc, 10));
2851
2852   /* should fail as of r580 */
2853   test_compare(TEST_SUCCESS,
2854                _user_supplied_bug21(memc, 1000));
2855
2856   return TEST_SUCCESS;
2857 }
2858
2859 test_return_t comparison_operator_memcached_st_and__memcached_return_t_TEST(memcached_st *)
2860 {
2861   test::Memc memc_;
2862
2863   memcached_st *memc= &memc_;
2864
2865   ASSERT_EQ(memc, MEMCACHED_SUCCESS);
2866   test_compare(memc, MEMCACHED_SUCCESS);
2867
2868   ASSERT_NEQ(memc, MEMCACHED_FAILURE);
2869
2870   return TEST_SUCCESS;
2871 }
2872
2873 test_return_t ketama_TEST(memcached_st *)
2874 {
2875   test::Memc memc("--server=10.0.1.1:11211 --server=10.0.1.2:11211");
2876
2877   test_compare(MEMCACHED_SUCCESS,
2878                memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true));
2879
2880   test_compare(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED), uint64_t(1));
2881
2882   test_compare(memcached_behavior_set(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5), MEMCACHED_SUCCESS);
2883
2884   test_compare(memcached_hash_t(memcached_behavior_get(&memc, MEMCACHED_BEHAVIOR_KETAMA_HASH)), MEMCACHED_HASH_MD5);
2885
2886   test_compare(memcached_behavior_set_distribution(&memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY), MEMCACHED_SUCCESS);
2887
2888
2889   return TEST_SUCCESS;
2890 }
2891
2892 test_return_t output_ketama_weighted_keys(memcached_st *)
2893 {
2894   memcached_st *memc= memcached_create(NULL);
2895   test_true(memc);
2896
2897
2898   test_compare(MEMCACHED_SUCCESS,
2899                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, true));
2900
2901   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2902   test_compare(value, uint64_t(1));
2903
2904   test_compare(MEMCACHED_SUCCESS,
2905                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5));
2906
2907   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2908   test_true(value == MEMCACHED_HASH_MD5);
2909
2910
2911   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
2912
2913   memcached_server_st *server_pool;
2914   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");
2915   memcached_server_push(memc, server_pool);
2916
2917   // @todo this needs to be refactored to actually test something.
2918 #if 0
2919   FILE *fp;
2920   if ((fp = fopen("ketama_keys.txt", "w")))
2921   {
2922     // noop
2923   } else {
2924     printf("cannot write to file ketama_keys.txt");
2925     return TEST_FAILURE;
2926   }
2927
2928   for (int x= 0; x < 10000; x++)
2929   {
2930     char key[10];
2931     snprintf(key, sizeof(key), "%d", x);
2932
2933     uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
2934     char *hostname = memc->hosts[server_idx].hostname;
2935     in_port_t port = memc->hosts[server_idx].port;
2936     fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
2937     const memcached_instance_st * instance=
2938       memcached_server_instance_by_position(memc, host_index);
2939   }
2940   fclose(fp);
2941 #endif
2942   memcached_server_list_free(server_pool);
2943   memcached_free(memc);
2944
2945   return TEST_SUCCESS;
2946 }
2947
2948
2949 test_return_t result_static(memcached_st *memc)
2950 {
2951   memcached_result_st result;
2952   memcached_result_st *result_ptr= memcached_result_create(memc, &result);
2953   test_false(result.options.is_allocated);
2954   test_true(memcached_is_initialized(&result));
2955   test_true(result_ptr);
2956   test_true(result_ptr == &result);
2957
2958   memcached_result_free(&result);
2959
2960   test_false(result.options.is_allocated);
2961   test_false(memcached_is_initialized(&result));
2962
2963   return TEST_SUCCESS;
2964 }
2965
2966 test_return_t result_alloc(memcached_st *memc)
2967 {
2968   memcached_result_st *result_ptr= memcached_result_create(memc, NULL);
2969   test_true(result_ptr);
2970   test_true(result_ptr->options.is_allocated);
2971   test_true(memcached_is_initialized(result_ptr));
2972   memcached_result_free(result_ptr);
2973
2974   return TEST_SUCCESS;
2975 }
2976
2977
2978 test_return_t add_host_test1(memcached_st *memc)
2979 {
2980   memcached_return_t rc;
2981   char servername[]= "0.example.com";
2982
2983   memcached_server_st *servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
2984   test_true(servers);
2985   test_compare(1U, memcached_server_list_count(servers));
2986
2987   for (uint32_t x= 2; x < 20; x++)
2988   {
2989     char buffer[SMALL_STRING_LEN];
2990
2991     snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
2992     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
2993                                                       &rc);
2994     test_compare(MEMCACHED_SUCCESS, rc);
2995     test_compare(x, memcached_server_list_count(servers));
2996   }
2997
2998   test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
2999   test_compare(MEMCACHED_SUCCESS, memcached_server_push(memc, servers));
3000
3001   memcached_server_list_free(servers);
3002
3003   return TEST_SUCCESS;
3004 }
3005
3006
3007 static void my_free(const memcached_st *ptr, void *mem, void *context)
3008 {
3009   (void)context;
3010   (void)ptr;
3011 #ifdef HARD_MALLOC_TESTS
3012   void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
3013   free(real_ptr);
3014 #else
3015   free(mem);
3016 #endif
3017 }
3018
3019
3020 static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
3021 {
3022   (void)context;
3023   (void)ptr;
3024 #ifdef HARD_MALLOC_TESTS
3025   void *ret= malloc(size + 8);
3026   if (ret != NULL)
3027   {
3028     ret= (void*)((caddr_t)ret + 8);
3029   }
3030 #else
3031   void *ret= malloc(size);
3032 #endif
3033
3034   if (ret != NULL)
3035   {
3036     memset(ret, 0xff, size);
3037   }
3038
3039   return ret;
3040 }
3041
3042
3043 static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *)
3044 {
3045 #ifdef HARD_MALLOC_TESTS
3046   void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
3047   void *nmem= realloc(real_ptr, size + 8);
3048
3049   void *ret= NULL;
3050   if (nmem != NULL)
3051   {
3052     ret= (void*)((caddr_t)nmem + 8);
3053   }
3054
3055   return ret;
3056 #else
3057   (void)ptr;
3058   return realloc(mem, size);
3059 #endif
3060 }
3061
3062
3063 static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *)
3064 {
3065 #ifdef HARD_MALLOC_TESTS
3066   void *mem= my_malloc(ptr, nelem * size);
3067   if (mem)
3068   {
3069     memset(mem, 0, nelem * size);
3070   }
3071
3072   return mem;
3073 #else
3074   (void)ptr;
3075   return calloc(nelem, size);
3076 #endif
3077 }
3078
3079 test_return_t selection_of_namespace_tests(memcached_st *memc)
3080 {
3081   memcached_return_t rc;
3082   const char *key= "mine";
3083   char *value;
3084
3085   /* Make sure by default none exists */
3086   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
3087   test_null(value);
3088   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
3089
3090   /* Test a clean set */
3091   test_compare(MEMCACHED_SUCCESS,
3092                memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
3093
3094   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
3095   test_true(value);
3096   test_memcmp(value, key, strlen(key));
3097   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
3098
3099   /* Test that we can turn it off */
3100   test_compare(MEMCACHED_SUCCESS,
3101                memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
3102
3103   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
3104   test_null(value);
3105   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
3106
3107   /* Now setup for main test */
3108   test_compare(MEMCACHED_SUCCESS,
3109                memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
3110
3111   value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
3112   test_true(value);
3113   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
3114   test_memcmp(value, key, strlen(key));
3115
3116   /* Set to Zero, and then Set to something too large */
3117   {
3118     char long_key[255];
3119     memset(long_key, 0, 255);
3120
3121     test_compare(MEMCACHED_SUCCESS,
3122                  memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, NULL));
3123
3124     ASSERT_NULL_(memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc), "Setting namespace to NULL did not work");
3125
3126     /* Test a long key for failure */
3127     /* TODO, extend test to determine based on setting, what result should be */
3128     strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
3129     test_compare(MEMCACHED_SUCCESS,
3130                  memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));
3131
3132     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3133     strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
3134     test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,
3135                  memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, long_key));
3136
3137     /* Test for a bad prefix, but with a short key */
3138     test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_INVALID_ARGUMENTS : MEMCACHED_SUCCESS,
3139                  memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1));
3140
3141     test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) ? MEMCACHED_SUCCESS : MEMCACHED_BAD_KEY_PROVIDED,
3142                  memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, "dog cat"));
3143   }
3144
3145   return TEST_SUCCESS;
3146 }
3147
3148 test_return_t set_namespace(memcached_st *memc)
3149 {
3150   memcached_return_t rc;
3151   const char *key= "mine";
3152
3153   // Make sure we default to a null namespace
3154   char* value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
3155   ASSERT_NULL_(value, "memc had a value for namespace when none should exist");
3156   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
3157
3158   /* Test a clean set */
3159   test_compare(MEMCACHED_SUCCESS,
3160                memcached_callback_set(memc, MEMCACHED_CALLBACK_NAMESPACE, (void *)key));
3161
3162   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_NAMESPACE, &rc);
3163   ASSERT_TRUE(value);
3164   test_memcmp(value, key, strlen(key));
3165   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
3166
3167   return TEST_SUCCESS;
3168 }
3169
3170 test_return_t set_namespace_and_binary(memcached_st *memc)
3171 {
3172   test_return_if(pre_binary(memc));
3173   test_return_if(set_namespace(memc));
3174
3175   return TEST_SUCCESS;
3176 }
3177
3178 #ifdef MEMCACHED_ENABLE_DEPRECATED
3179 test_return_t deprecated_set_memory_alloc(memcached_st *memc)
3180 {
3181   void *test_ptr= NULL;
3182   void *cb_ptr= NULL;
3183   {
3184     memcached_malloc_fn malloc_cb= (memcached_malloc_fn)my_malloc;
3185     cb_ptr= *(void **)&malloc_cb;
3186     memcached_return_t rc;
3187
3188     test_compare(MEMCACHED_SUCCESS,
3189                  memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr));
3190     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3191     test_compare(MEMCACHED_SUCCESS, rc);
3192     test_true(test_ptr == cb_ptr);
3193   }
3194
3195   {
3196     memcached_realloc_fn realloc_cb=
3197       (memcached_realloc_fn)my_realloc;
3198     cb_ptr= *(void **)&realloc_cb;
3199     memcached_return_t rc;
3200
3201     test_compare(MEMCACHED_SUCCESS,
3202                  memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr));
3203     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3204     test_compare(MEMCACHED_SUCCESS, rc);
3205     test_true(test_ptr == cb_ptr);
3206   }
3207
3208   {
3209     memcached_free_fn free_cb=
3210       (memcached_free_fn)my_free;
3211     cb_ptr= *(void **)&free_cb;
3212     memcached_return_t rc;
3213
3214     test_compare(MEMCACHED_SUCCESS,
3215                  memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr));
3216     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3217     test_compare(MEMCACHED_SUCCESS, rc);
3218     test_true(test_ptr == cb_ptr);
3219   }
3220
3221   return TEST_SUCCESS;
3222 }
3223 #endif
3224
3225
3226 test_return_t set_memory_alloc(memcached_st *memc)
3227 {
3228   test_compare(MEMCACHED_INVALID_ARGUMENTS,
3229                memcached_set_memory_allocators(memc, NULL, my_free,
3230                                                my_realloc, my_calloc, NULL));
3231
3232   test_compare(MEMCACHED_SUCCESS,
3233                memcached_set_memory_allocators(memc, my_malloc, my_free,
3234                                                my_realloc, my_calloc, NULL));
3235
3236   memcached_malloc_fn mem_malloc;
3237   memcached_free_fn mem_free;
3238   memcached_realloc_fn mem_realloc;
3239   memcached_calloc_fn mem_calloc;
3240   memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
3241                                   &mem_realloc, &mem_calloc);
3242
3243   test_true(mem_malloc == my_malloc);
3244   test_true(mem_realloc == my_realloc);
3245   test_true(mem_calloc == my_calloc);
3246   test_true(mem_free == my_free);
3247
3248   return TEST_SUCCESS;
3249 }
3250
3251 test_return_t enable_consistent_crc(memcached_st *memc)
3252 {
3253   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT));
3254   test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION),  uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT));
3255
3256   test_return_t rc;
3257   if ((rc= pre_crc(memc)) != TEST_SUCCESS)
3258   {
3259     return rc;
3260   }
3261
3262   test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION),  uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT));
3263
3264   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH) != MEMCACHED_HASH_CRC)
3265   {
3266     return TEST_SKIPPED;
3267   }
3268
3269   return TEST_SUCCESS;
3270 }
3271
3272 test_return_t enable_consistent_hsieh(memcached_st *memc)
3273 {
3274   test_return_t rc;
3275   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT);
3276   if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
3277   {
3278     return rc;
3279   }
3280
3281   test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION), uint64_t(MEMCACHED_DISTRIBUTION_CONSISTENT));
3282
3283   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH) != MEMCACHED_HASH_HSIEH)
3284   {
3285     return TEST_SKIPPED;
3286   }
3287
3288   return TEST_SUCCESS;
3289 }
3290
3291 test_return_t enable_cas(memcached_st *memc)
3292 {
3293   if (libmemcached_util_version_check(memc, 1, 2, 4))
3294   {
3295     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true);
3296
3297     return TEST_SUCCESS;
3298   }
3299
3300   return TEST_SKIPPED;
3301 }
3302
3303 test_return_t check_for_1_2_3(memcached_st *memc)
3304 {
3305   memcached_version(memc);
3306
3307   const memcached_instance_st * instance=
3308     memcached_server_instance_by_position(memc, 0);
3309
3310   if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
3311       or instance->minor_version > 2)
3312   {
3313     return TEST_SUCCESS;
3314   }
3315
3316   return TEST_SKIPPED;
3317 }
3318
3319 test_return_t MEMCACHED_BEHAVIOR_POLL_TIMEOUT_test(memcached_st *memc)
3320 {
3321   const uint64_t timeout= 100; // Not using, just checking that it sets
3322
3323   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
3324
3325   test_compare(timeout, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT));
3326
3327   return TEST_SUCCESS;
3328 }
3329
3330 test_return_t noreply_test(memcached_st *memc)
3331 {
3332   test_compare(MEMCACHED_SUCCESS,
3333                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, true));
3334   test_compare(MEMCACHED_SUCCESS,
3335                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true));
3336   test_compare(MEMCACHED_SUCCESS,
3337                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, true));
3338   test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY));
3339   test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS));
3340   test_compare(1LLU, memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS));
3341
3342   memcached_return_t ret;
3343   for (int count= 0; count < 5; ++count)
3344   {
3345     for (size_t x= 0; x < 100; ++x)
3346     {
3347       char key[MEMCACHED_MAXIMUM_INTEGER_DISPLAY_LENGTH +1];
3348       int check_length= snprintf(key, sizeof(key), "%lu", (unsigned long)x);
3349       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
3350
3351       size_t len= (size_t)check_length;
3352
3353       switch (count)
3354       {
3355       case 0:
3356         ret= memcached_add(memc, key, len, key, len, 0, 0);
3357         break;
3358       case 1:
3359         ret= memcached_replace(memc, key, len, key, len, 0, 0);
3360         break;
3361       case 2:
3362         ret= memcached_set(memc, key, len, key, len, 0, 0);
3363         break;
3364       case 3:
3365         ret= memcached_append(memc, key, len, key, len, 0, 0);
3366         break;
3367       case 4:
3368         ret= memcached_prepend(memc, key, len, key, len, 0, 0);
3369         break;
3370       default:
3371         test_true(count);
3372         break;
3373       }
3374       test_true_got(ret == MEMCACHED_SUCCESS or ret == MEMCACHED_BUFFERED,
3375                     memcached_strerror(NULL, ret));
3376     }
3377
3378     /*
3379      ** NOTE: Don't ever do this in your code! this is not a supported use of the
3380      ** API and is _ONLY_ done this way to verify that the library works the
3381      ** way it is supposed to do!!!!
3382    */
3383 #if 0
3384     int no_msg=0;
3385     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
3386     {
3387       const memcached_instance_st * instance=
3388         memcached_server_instance_by_position(memc, x);
3389       no_msg+=(int)(instance->cursor_active);
3390     }
3391
3392     test_true(no_msg == 0);
3393 #endif
3394     test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
3395
3396     /*
3397      ** Now validate that all items was set properly!
3398    */
3399     for (size_t x= 0; x < 100; ++x)
3400     {
3401       char key[10];
3402
3403       int check_length= snprintf(key, sizeof(key), "%lu", (unsigned long)x);
3404
3405       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
3406
3407       size_t len= (size_t)check_length;
3408       size_t length;
3409       uint32_t flags;
3410       char* value=memcached_get(memc, key, strlen(key),
3411                                 &length, &flags, &ret);
3412       // For the moment we will just go to the next key
3413       if (MEMCACHED_TIMEOUT == ret)
3414       {
3415         continue;
3416       }
3417       test_true(ret == MEMCACHED_SUCCESS and value != NULL);
3418       switch (count)
3419       {
3420       case 0: /* FALLTHROUGH */
3421       case 1: /* FALLTHROUGH */
3422       case 2:
3423         test_true(strncmp(value, key, len) == 0);
3424         test_true(len == length);
3425         break;
3426       case 3:
3427         test_true(length == len * 2);
3428         break;
3429       case 4:
3430         test_true(length == len * 3);
3431         break;
3432       default:
3433         test_true(count);
3434         break;
3435       }
3436       free(value);
3437     }
3438   }
3439
3440   /* Try setting an illegal cas value (should not return an error to
3441    * the caller (because we don't expect a return message from the server)
3442  */
3443   const char* keys[]= {"0"};
3444   size_t lengths[]= {1};
3445   size_t length;
3446   uint32_t flags;
3447   memcached_result_st results_obj;
3448   memcached_result_st *results;
3449   test_compare(MEMCACHED_SUCCESS,
3450                memcached_mget(memc, keys, lengths, 1));
3451
3452   results= memcached_result_create(memc, &results_obj);
3453   test_true(results);
3454   results= memcached_fetch_result(memc, &results_obj, &ret);
3455   test_true(results);
3456   test_compare(MEMCACHED_SUCCESS, ret);
3457   uint64_t cas= memcached_result_cas(results);
3458   memcached_result_free(&results_obj);
3459
3460   test_compare(MEMCACHED_SUCCESS,
3461                memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas));
3462
3463   /*
3464    * The item will have a new cas value, so try to set it again with the old
3465    * value. This should fail!
3466  */
3467   test_compare(MEMCACHED_SUCCESS,
3468                memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas));
3469   test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
3470   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
3471   test_true(ret == MEMCACHED_SUCCESS && value != NULL);
3472   free(value);
3473
3474   return TEST_SUCCESS;
3475 }
3476
3477 test_return_t analyzer_test(memcached_st *memc)
3478 {
3479   memcached_analysis_st *report;
3480   memcached_return_t rc;
3481
3482   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
3483   test_compare(MEMCACHED_SUCCESS, rc);
3484   test_true(memc_stat);
3485
3486   report= memcached_analyze(memc, memc_stat, &rc);
3487   test_compare(MEMCACHED_SUCCESS, rc);
3488   test_true(report);
3489
3490   free(report);
3491   memcached_stat_free(NULL, memc_stat);
3492
3493   return TEST_SUCCESS;
3494 }
3495
3496 test_return_t util_version_test(memcached_st *memc)
3497 {
3498   test_compare(memcached_version(memc), MEMCACHED_SUCCESS);
3499   test_true(libmemcached_util_version_check(memc, 0, 0, 0));
3500
3501   bool if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
3502
3503   // We expect failure
3504   if (if_successful)
3505   {
3506     fprintf(stderr, "\n----------------------------------------------------------------------\n");
3507     fprintf(stderr, "\nDumping Server Information\n\n");
3508     memcached_server_fn callbacks[1];
3509
3510     callbacks[0]= dump_server_information;
3511     memcached_server_cursor(memc, callbacks, (void *)stderr,  1);
3512     fprintf(stderr, "\n----------------------------------------------------------------------\n");
3513   }
3514   test_true(if_successful == false);
3515
3516   const memcached_instance_st * instance=
3517     memcached_server_instance_by_position(memc, 0);
3518
3519   memcached_version(memc);
3520
3521   // We only use one binary when we test, so this should be just fine.
3522   if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
3523   test_true(if_successful == true);
3524
3525   if (instance->micro_version > 0)
3526   {
3527     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
3528   }
3529   else if (instance->minor_version > 0)
3530   {
3531     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
3532   }
3533   else if (instance->major_version > 0)
3534   {
3535     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
3536   }
3537
3538   test_true(if_successful == true);
3539
3540   if (instance->micro_version > 0)
3541   {
3542     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
3543   }
3544   else if (instance->minor_version > 0)
3545   {
3546     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
3547   }
3548   else if (instance->major_version > 0)
3549   {
3550     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
3551   }
3552
3553   test_true(if_successful == false);
3554
3555   return TEST_SUCCESS;
3556 }
3557
3558 test_return_t getpid_connection_failure_test(memcached_st *memc)
3559 {
3560   test_skip(memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
3561   memcached_return_t rc;
3562   const memcached_instance_st * instance=
3563     memcached_server_instance_by_position(memc, 0);
3564
3565   // Test both the version that returns a code, and the one that does not.
3566   test_true(libmemcached_util_getpid(memcached_server_name(instance),
3567                                      memcached_server_port(instance) -1, NULL) == -1);
3568
3569   test_true(libmemcached_util_getpid(memcached_server_name(instance),
3570                                      memcached_server_port(instance) -1, &rc) == -1);
3571   test_compare_got(MEMCACHED_CONNECTION_FAILURE, rc, memcached_strerror(memc, rc));
3572
3573   return TEST_SUCCESS;
3574 }
3575
3576
3577 test_return_t getpid_test(memcached_st *memc)
3578 {
3579   memcached_return_t rc;
3580   const memcached_instance_st * instance=
3581     memcached_server_instance_by_position(memc, 0);
3582
3583   // Test both the version that returns a code, and the one that does not.
3584   test_true(libmemcached_util_getpid(memcached_server_name(instance),
3585                                      memcached_server_port(instance), NULL) > -1);
3586
3587   test_true(libmemcached_util_getpid(memcached_server_name(instance),
3588                                      memcached_server_port(instance), &rc) > -1);
3589   test_compare(MEMCACHED_SUCCESS, rc);
3590
3591   return TEST_SUCCESS;
3592 }
3593
3594 static memcached_return_t ping_each_server(const memcached_st*,
3595                                            const memcached_instance_st * instance,
3596                                            void*)
3597 {
3598   // Test both the version that returns a code, and the one that does not.
3599   memcached_return_t rc;
3600   if (libmemcached_util_ping(memcached_server_name(instance),
3601                              memcached_server_port(instance), &rc) == false)
3602   {
3603     throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "%s:%d %s", memcached_server_name(instance),
3604                          memcached_server_port(instance), memcached_strerror(NULL, rc));
3605   }
3606
3607   if (libmemcached_util_ping(memcached_server_name(instance),
3608                                    memcached_server_port(instance), NULL) == false)
3609   {
3610     throw libtest::fatal(LIBYATL_DEFAULT_PARAM, "%s:%d", memcached_server_name(instance), memcached_server_port(instance));
3611   }
3612
3613   return MEMCACHED_SUCCESS;
3614 }
3615
3616 test_return_t libmemcached_util_ping_TEST(memcached_st *memc)
3617 {
3618   memcached_server_fn callbacks[1]= { ping_each_server };
3619   memcached_server_cursor(memc, callbacks, NULL,  1);
3620
3621   return TEST_SUCCESS;
3622 }
3623
3624
3625 #if 0
3626 test_return_t hash_sanity_test (memcached_st *memc)
3627 {
3628   (void)memc;
3629
3630   assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
3631   assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
3632   assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
3633   assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
3634   assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
3635   assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
3636   assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
3637 #ifdef HAVE_HSIEH_HASH
3638   assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
3639 #endif
3640   assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
3641   assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
3642   assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
3643
3644   return TEST_SUCCESS;
3645 }
3646 #endif
3647
3648 test_return_t hsieh_avaibility_test (memcached_st *memc)
3649 {
3650   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
3651
3652   test_compare(MEMCACHED_SUCCESS,
3653                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
3654                                       (uint64_t)MEMCACHED_HASH_HSIEH));
3655
3656   return TEST_SUCCESS;
3657 }
3658
3659 test_return_t murmur_avaibility_test (memcached_st *memc)
3660 {
3661   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
3662
3663   test_compare(MEMCACHED_SUCCESS,
3664                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR));
3665
3666   return TEST_SUCCESS;
3667 }
3668
3669 test_return_t one_at_a_time_run (memcached_st *)
3670 {
3671   uint32_t x;
3672   const char **ptr;
3673
3674   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3675   {
3676     test_compare(one_at_a_time_values[x],
3677                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT));
3678   }
3679
3680   return TEST_SUCCESS;
3681 }
3682
3683 test_return_t md5_run (memcached_st *)
3684 {
3685   uint32_t x;
3686   const char **ptr;
3687
3688   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3689   {
3690     test_compare(md5_values[x],
3691                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5));
3692   }
3693
3694   return TEST_SUCCESS;
3695 }
3696
3697 test_return_t crc_run (memcached_st *)
3698 {
3699   uint32_t x;
3700   const char **ptr;
3701
3702   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3703   {
3704     test_compare(crc_values[x],
3705                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC));
3706   }
3707
3708   return TEST_SUCCESS;
3709 }
3710
3711 test_return_t fnv1_64_run (memcached_st *)
3712 {
3713   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1_64));
3714
3715   uint32_t x;
3716   const char **ptr;
3717
3718   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3719   {
3720     test_compare(fnv1_64_values[x],
3721                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64));
3722   }
3723
3724   return TEST_SUCCESS;
3725 }
3726
3727 test_return_t fnv1a_64_run (memcached_st *)
3728 {
3729   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_FNV1A_64));
3730
3731   uint32_t x;
3732   const char **ptr;
3733
3734   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3735   {
3736     test_compare(fnv1a_64_values[x],
3737                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64));
3738   }
3739
3740   return TEST_SUCCESS;
3741 }
3742
3743 test_return_t fnv1_32_run (memcached_st *)
3744 {
3745   uint32_t x;
3746   const char **ptr;
3747
3748   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3749   {
3750     test_compare(fnv1_32_values[x],
3751                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32));
3752   }
3753
3754   return TEST_SUCCESS;
3755 }
3756
3757 test_return_t fnv1a_32_run (memcached_st *)
3758 {
3759   uint32_t x;
3760   const char **ptr;
3761
3762   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3763   {
3764     test_compare(fnv1a_32_values[x],
3765                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32));
3766   }
3767
3768   return TEST_SUCCESS;
3769 }
3770
3771 test_return_t hsieh_run (memcached_st *)
3772 {
3773   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_HSIEH));
3774
3775   uint32_t x;
3776   const char **ptr;
3777
3778   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3779   {
3780     test_compare(hsieh_values[x],
3781                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH));
3782   }
3783
3784   return TEST_SUCCESS;
3785 }
3786
3787 test_return_t murmur_run (memcached_st *)
3788 {
3789   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR));
3790
3791 #ifdef WORDS_BIGENDIAN
3792   (void)murmur_values;
3793   return TEST_SKIPPED;
3794 #else
3795   uint32_t x;
3796   const char **ptr;
3797
3798   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3799   {
3800     test_compare(murmur_values[x],
3801                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR));
3802   }
3803
3804   return TEST_SUCCESS;
3805 #endif
3806 }
3807
3808 test_return_t murmur3_TEST(hashkit_st *)
3809 {
3810   test_skip(true, libhashkit_has_algorithm(HASHKIT_HASH_MURMUR3));
3811
3812 #ifdef WORDS_BIGENDIAN
3813   (void)murmur3_values;
3814   return TEST_SKIPPED;
3815 #else
3816   uint32_t x;
3817   const char **ptr;
3818
3819   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3820   {
3821     test_compare(murmur3_values[x],
3822                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR3));
3823   }
3824
3825   return TEST_SUCCESS;
3826 #endif
3827 }
3828
3829 test_return_t jenkins_run (memcached_st *)
3830 {
3831   uint32_t x;
3832   const char **ptr;
3833
3834   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3835   {
3836     test_compare(jenkins_values[x],
3837                  memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS));
3838   }
3839
3840   return TEST_SUCCESS;
3841 }
3842
3843 static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *)
3844 {
3845   return libhashkit_md5(string, string_length);
3846 }
3847
3848 static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *)
3849 {
3850   return libhashkit_crc32(string, string_length);
3851 }
3852
3853 test_return_t memcached_get_hashkit_test (memcached_st *)
3854 {
3855   uint32_t x;
3856   const char **ptr;
3857   hashkit_st new_kit;
3858
3859   memcached_st *memc= memcached(test_literal_param("--server=localhost:1 --server=localhost:2 --server=localhost:3 --server=localhost:4 --server=localhost5 --DISTRIBUTION=modula"));
3860
3861   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};
3862   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};
3863
3864   const hashkit_st *kit= memcached_get_hashkit(memc);
3865
3866   hashkit_clone(&new_kit, kit);
3867   test_compare(HASHKIT_SUCCESS, hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL));
3868
3869   memcached_set_hashkit(memc, &new_kit);
3870
3871   /*
3872     Verify Setting the hash.
3873   */
3874   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3875   {
3876     uint32_t hash_val;
3877
3878     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
3879     test_compare_got(md5_values[x], hash_val, *ptr);
3880   }
3881
3882
3883   /*
3884     Now check memcached_st.
3885   */
3886   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3887   {
3888     uint32_t hash_val;
3889
3890     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
3891     test_compare_got(md5_hosts[x], hash_val, *ptr);
3892   }
3893
3894   test_compare(HASHKIT_SUCCESS, hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL));
3895
3896   memcached_set_hashkit(memc, &new_kit);
3897
3898   /*
3899     Verify Setting the hash.
3900   */
3901   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3902   {
3903     uint32_t hash_val;
3904
3905     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
3906     test_true(crc_values[x] == hash_val);
3907   }
3908
3909   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
3910   {
3911     uint32_t hash_val;
3912
3913     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
3914     test_compare(crc_hosts[x], hash_val);
3915   }
3916
3917   memcached_free(memc);
3918
3919   return TEST_SUCCESS;
3920 }
3921
3922 /*
3923   Test case adapted from John Gorman <johngorman2@gmail.com>
3924
3925   We are testing the error condition when we connect to a server via memcached_get()
3926   but find that the server is not available.
3927 */
3928 test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *)
3929 {
3930   size_t len;
3931   uint32_t flags;
3932   memcached_return rc;
3933
3934   // Create a handle.
3935   memcached_st *tl_memc_h= memcached(test_literal_param("--server=localhost:9898 --server=localhost:9899")); // This server should not exist
3936
3937   // See if memcached is reachable.
3938   char *value= memcached_get(tl_memc_h,
3939                              test_literal_param(__func__),
3940                              &len, &flags, &rc);
3941
3942   test_false(value);
3943   test_zero(len);
3944   test_true(memcached_failed(rc));
3945
3946   memcached_free(tl_memc_h);
3947
3948   return TEST_SUCCESS;
3949 }
3950
3951 /*
3952   We connect to a server which exists, but search for a key that does not exist.
3953 */
3954 test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
3955 {
3956   size_t len;
3957   uint32_t flags;
3958   memcached_return rc;
3959
3960   // See if memcached is reachable.
3961   char *value= memcached_get(memc,
3962                              test_literal_param(__func__),
3963                              &len, &flags, &rc);
3964
3965   test_false(value);
3966   test_zero(len);
3967   test_compare(MEMCACHED_NOTFOUND, rc);
3968
3969   return TEST_SUCCESS;
3970 }
3971
3972 /*
3973   Test case adapted from John Gorman <johngorman2@gmail.com>
3974
3975   We are testing the error condition when we connect to a server via memcached_get_by_key()
3976   but find that the server is not available.
3977 */
3978 test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *)
3979 {
3980   size_t len;
3981   uint32_t flags;
3982   memcached_return rc;
3983
3984   // Create a handle.
3985   memcached_st *tl_memc_h= memcached_create(NULL);
3986   memcached_server_st *servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
3987   memcached_server_push(tl_memc_h, servers);
3988   memcached_server_list_free(servers);
3989
3990   // See if memcached is reachable.
3991   char *value= memcached_get_by_key(tl_memc_h,
3992                                     test_literal_param(__func__), // Key
3993                                     test_literal_param(__func__), // Value
3994                                     &len, &flags, &rc);
3995
3996   test_false(value);
3997   test_zero(len);
3998   test_true(memcached_failed(rc));
3999
4000   memcached_free(tl_memc_h);
4001
4002   return TEST_SUCCESS;
4003 }
4004
4005 /*
4006   We connect to a server which exists, but search for a key that does not exist.
4007 */
4008 test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
4009 {
4010   size_t len;
4011   uint32_t flags;
4012   memcached_return rc;
4013
4014   // See if memcached is reachable.
4015   char *value= memcached_get_by_key(memc,
4016                                     test_literal_param(__func__), // Key
4017                                     test_literal_param(__func__), // Value
4018                                     &len, &flags, &rc);
4019
4020   test_false(value);
4021   test_zero(len);
4022   test_compare(MEMCACHED_NOTFOUND, rc);
4023
4024   return TEST_SUCCESS;
4025 }
4026
4027 test_return_t regression_bug_434484(memcached_st *memc)
4028 {
4029   test_skip(TEST_SUCCESS, pre_binary(memc));
4030
4031   test_compare(MEMCACHED_NOTSTORED,
4032                memcached_append(memc,
4033                                 test_literal_param(__func__), // Key
4034                                 test_literal_param(__func__), // Value
4035                                 0, 0));
4036
4037   libtest::vchar_t data;
4038   data.resize(2048 * 1024);
4039   test_compare(MEMCACHED_E2BIG,
4040                memcached_set(memc,
4041                              test_literal_param(__func__), // Key
4042                              &data[0], data.size(), 0, 0));
4043
4044   return TEST_SUCCESS;
4045 }
4046
4047 test_return_t regression_bug_434843(memcached_st *original_memc)
4048 {
4049   test_skip(TEST_SUCCESS, pre_binary(original_memc));
4050
4051   memcached_return_t rc;
4052   size_t counter= 0;
4053   memcached_execute_fn callbacks[]= { &callback_counter };
4054
4055   /*
4056    * I only want to hit only _one_ server so I know the number of requests I'm
4057    * sending in the pipleine to the server. Let's try to do a multiget of
4058    * 1024 (that should satisfy most users don't you think?). Future versions
4059    * will include a mget_execute function call if you need a higher number.
4060  */
4061   memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL");
4062
4063   keys_st keys(1024);
4064
4065   /*
4066    * Run two times.. the first time we should have 100% cache miss,
4067    * and the second time we should have 100% cache hits
4068  */
4069   for (ptrdiff_t y= 0; y < 2; y++)
4070   {
4071     test_compare(MEMCACHED_SUCCESS,
4072                  memcached_mget(memc, keys.keys_ptr(), keys.lengths_ptr(), keys.size()));
4073
4074     // One the first run we should get a NOT_FOUND, but on the second some data
4075     // should be returned.
4076     test_compare(y ?  MEMCACHED_SUCCESS : MEMCACHED_NOTFOUND,
4077                  memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
4078
4079     if (y == 0)
4080     {
4081       /* The first iteration should give me a 100% cache miss. verify that*/
4082       char blob[1024]= { 0 };
4083
4084       test_false(counter);
4085
4086       for (size_t x= 0; x < keys.size(); ++x)
4087       {
4088         rc= memcached_add(memc,
4089                           keys.key_at(x), keys.length_at(x),
4090                           blob, sizeof(blob), 0, 0);
4091         test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
4092       }
4093     }
4094     else
4095     {
4096       /* Verify that we received all of the key/value pairs */
4097       test_compare(counter, keys.size());
4098     }
4099   }
4100
4101   memcached_free(memc);
4102
4103   return TEST_SUCCESS;
4104 }
4105
4106 test_return_t regression_bug_434843_buffered(memcached_st *memc)
4107 {
4108   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, true));
4109
4110   return regression_bug_434843(memc);
4111 }
4112
4113 test_return_t regression_bug_421108(memcached_st *memc)
4114 {
4115   memcached_return_t rc;
4116   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
4117   test_compare(MEMCACHED_SUCCESS, rc);
4118
4119   char *bytes_str= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
4120   test_compare(MEMCACHED_SUCCESS, rc);
4121   test_true(bytes_str);
4122   char *bytes_read_str= memcached_stat_get_value(memc, memc_stat,
4123                                                  "bytes_read", &rc);
4124   test_compare(MEMCACHED_SUCCESS, rc);
4125   test_true(bytes_read_str);
4126
4127   char *bytes_written_str= memcached_stat_get_value(memc, memc_stat,
4128                                                     "bytes_written", &rc);
4129   test_compare(MEMCACHED_SUCCESS, rc);
4130   test_true(bytes_written_str);
4131
4132   unsigned long long bytes= strtoull(bytes_str, 0, 10);
4133   unsigned long long bytes_read= strtoull(bytes_read_str, 0, 10);
4134   unsigned long long bytes_written= strtoull(bytes_written_str, 0, 10);
4135
4136   test_true(bytes != bytes_read);
4137   test_true(bytes != bytes_written);
4138
4139   /* Release allocated resources */
4140   free(bytes_str);
4141   free(bytes_read_str);
4142   free(bytes_written_str);
4143   memcached_stat_free(NULL, memc_stat);
4144
4145   return TEST_SUCCESS;
4146 }
4147
4148 /*
4149  * The test case isn't obvious so I should probably document why
4150  * it works the way it does. Bug 442914 was caused by a bug
4151  * in the logic in memcached_purge (it did not handle the case
4152  * where the number of bytes sent was equal to the watermark).
4153  * In this test case, create messages so that we hit that case
4154  * and then disable noreply mode and issue a new command to
4155  * verify that it isn't stuck. If we change the format for the
4156  * delete command or the watermarks, we need to update this
4157  * test....
4158  */
4159 test_return_t regression_bug_442914(memcached_st *original_memc)
4160 {
4161   test_skip(original_memc->servers[0].type, MEMCACHED_CONNECTION_TCP);
4162
4163   memcached_st* memc= create_single_instance_memcached(original_memc, "--NOREPLY --TCP-NODELAY");
4164
4165   for (uint32_t x= 0; x < 250; ++x)
4166   {
4167     char key[250];
4168     size_t len= (size_t)snprintf(key, sizeof(key), "%0250u", x);
4169     memcached_return_t rc= memcached_delete(memc, key, len, 0);
4170     char error_buffer[2048]= { 0 };
4171     snprintf(error_buffer, sizeof(error_buffer), "%s key: %s", memcached_last_error_message(memc), key);
4172     test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, error_buffer);
4173   }
4174
4175   // Delete, and then delete again to look for not found
4176   {
4177     char key[250];
4178     size_t len= snprintf(key, sizeof(key), "%037u", 251U);
4179     memcached_return_t rc= memcached_delete(memc, key, len, 0);
4180     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
4181
4182     test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, false));
4183     test_compare(MEMCACHED_NOTFOUND, memcached_delete(memc, key, len, 0));
4184   }
4185
4186   memcached_free(memc);
4187
4188   return TEST_SUCCESS;
4189 }
4190
4191 test_return_t regression_bug_447342(memcached_st *memc)
4192 {
4193   if (memcached_server_count(memc) < 3 or pre_replication(memc) != TEST_SUCCESS)
4194   {
4195     return TEST_SKIPPED;
4196   }
4197
4198   test_compare(MEMCACHED_SUCCESS,
4199                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2));
4200
4201   keys_st keys(100);
4202
4203   for (size_t x= 0; x < keys.size(); ++x)
4204   {
4205     test_compare(MEMCACHED_SUCCESS,
4206                  memcached_set(memc,
4207                                keys.key_at(x), keys.length_at(x), // Keys
4208                                keys.key_at(x), keys.length_at(x), // Values
4209                                0, 0));
4210   }
4211
4212   /*
4213    ** We are using the quiet commands to store the replicas, so we need
4214    ** to ensure that all of them are processed before we can continue.
4215    ** In the test we go directly from storing the object to trying to
4216    ** receive the object from all of the different servers, so we
4217    ** could end up in a race condition (the memcached server hasn't yet
4218    ** processed the quiet command from the replication set when it process
4219    ** the request from the other client (created by the clone)). As a
4220    ** workaround for that we call memcached_quit to send the quit command
4221    ** to the server and wait for the response ;-) If you use the test code
4222    ** as an example for your own code, please note that you shouldn't need
4223    ** to do this ;-)
4224  */
4225   memcached_quit(memc);
4226
4227   /* Verify that all messages are stored, and we didn't stuff too much
4228    * into the servers
4229  */
4230   test_compare(MEMCACHED_SUCCESS,
4231                memcached_mget(memc,
4232                               keys.keys_ptr(), keys.lengths_ptr(), keys.size()));
4233
4234   unsigned int counter= 0;
4235   memcached_execute_fn callbacks[]= { &callback_counter };
4236   test_compare(MEMCACHED_SUCCESS,
4237                memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
4238
4239   /* Verify that we received all of the key/value pairs */
4240   test_compare(counter, keys.size());
4241
4242   memcached_quit(memc);
4243   /*
4244    * Don't do the following in your code. I am abusing the internal details
4245    * within the library, and this is not a supported interface.
4246    * This is to verify correct behavior in the library. Fake that two servers
4247    * are dead..
4248  */
4249   const memcached_instance_st * instance_one= memcached_server_instance_by_position(memc, 0);
4250   const memcached_instance_st * instance_two= memcached_server_instance_by_position(memc, 2);
4251   in_port_t port0= instance_one->port();
4252   in_port_t port2= instance_two->port();
4253
4254   ((memcached_server_write_instance_st)instance_one)->port(0);
4255   ((memcached_server_write_instance_st)instance_two)->port(0);
4256
4257   test_compare(MEMCACHED_SUCCESS,
4258                memcached_mget(memc,
4259                               keys.keys_ptr(), keys.lengths_ptr(), keys.size()));
4260
4261   counter= 0;
4262   test_compare(MEMCACHED_SUCCESS,
4263                memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
4264   test_compare(counter, keys.size());
4265
4266   /* restore the memc handle */
4267   ((memcached_server_write_instance_st)instance_one)->port(port0);
4268   ((memcached_server_write_instance_st)instance_two)->port(port2);
4269
4270   memcached_quit(memc);
4271
4272   /* Remove half of the objects */
4273   for (size_t x= 0; x < keys.size(); ++x)
4274   {
4275     if (x & 1)
4276     {
4277       test_compare(MEMCACHED_SUCCESS,
4278                    memcached_delete(memc, keys.key_at(x), keys.length_at(x), 0));
4279     }
4280   }
4281
4282   memcached_quit(memc);
4283   ((memcached_server_write_instance_st)instance_one)->port(0);
4284   ((memcached_server_write_instance_st)instance_two)->port(0);
4285
4286   /* now retry the command, this time we should have cache misses */
4287   test_compare(MEMCACHED_SUCCESS,
4288                memcached_mget(memc,
4289                               keys.keys_ptr(), keys.lengths_ptr(), keys.size()));
4290
4291   counter= 0;
4292   test_compare(MEMCACHED_SUCCESS,
4293                memcached_fetch_execute(memc, callbacks, (void *)&counter, 1));
4294   test_compare(counter, (unsigned int)(keys.size() >> 1));
4295
4296   /* restore the memc handle */
4297   ((memcached_server_write_instance_st)instance_one)->port(port0);
4298   ((memcached_server_write_instance_st)instance_two)->port(port2);
4299
4300   return TEST_SUCCESS;
4301 }
4302
4303 test_return_t regression_bug_463297(memcached_st *memc)
4304 {
4305   test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc, "foo", 3, 1));
4306
4307   // Since we blocked timed delete, this test is no longer valid.
4308 #if 0
4309   memcached_st *memc_clone= memcached_clone(NULL, memc);
4310   test_true(memc_clone);
4311   test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
4312
4313   const memcached_instance_st * instance=
4314     memcached_server_instance_by_position(memc_clone, 0);
4315
4316   if (instance->major_version > 1 ||
4317       (instance->major_version == 1 &&
4318        instance->minor_version > 2))
4319   {
4320     /* Binary protocol doesn't support deferred delete */
4321     memcached_st *bin_clone= memcached_clone(NULL, memc);
4322     test_true(bin_clone);
4323     test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
4324     test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(bin_clone, "foo", 3, 1));
4325     memcached_free(bin_clone);
4326
4327     memcached_quit(memc_clone);
4328
4329     /* If we know the server version, deferred delete should fail
4330      * with invalid arguments */
4331     test_compare(MEMCACHED_INVALID_ARGUMENTS, memcached_delete(memc_clone, "foo", 3, 1));
4332
4333     /* If we don't know the server version, we should get a protocol error */
4334     memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
4335
4336     /* but there is a bug in some of the memcached servers (1.4) that treats
4337      * the counter as noreply so it doesn't send the proper error message
4338    */
4339     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
4340
4341     /* And buffered mode should be disabled and we should get protocol error */
4342     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
4343     rc= memcached_delete(memc, "foo", 3, 1);
4344     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
4345
4346     /* Same goes for noreply... */
4347     test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1));
4348     rc= memcached_delete(memc, "foo", 3, 1);
4349     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
4350
4351     /* but a normal request should go through (and be buffered) */
4352     test_compare(MEMCACHED_BUFFERED, (rc= memcached_delete(memc, "foo", 3, 0)));
4353     test_compare(MEMCACHED_SUCCESS, memcached_flush_buffers(memc));
4354
4355     test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0));
4356     /* unbuffered noreply should be success */
4357     test_compare(MEMCACHED_SUCCESS, memcached_delete(memc, "foo", 3, 0));
4358     /* unbuffered with reply should be not found... */
4359     test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0));
4360     test_compare(MEMCACHED_NOTFOUND, memcached_delete(memc, "foo", 3, 0));
4361   }
4362
4363   memcached_free(memc_clone);
4364 #endif
4365
4366   return TEST_SUCCESS;
4367 }
4368
4369
4370 /* Test memcached_server_get_last_disconnect
4371  * For a working server set, shall be NULL
4372  * For a set of non existing server, shall not be NULL
4373  */
4374 test_return_t test_get_last_disconnect(memcached_st *memc)
4375 {
4376   memcached_return_t rc;
4377   const memcached_instance_st * disconnected_server;
4378
4379   /* With the working set of server */
4380   const char *key= "marmotte";
4381   const char *value= "milka";
4382
4383   memcached_reset_last_disconnected_server(memc);
4384   test_false(memc->last_disconnected_server);
4385   rc= memcached_set(memc, key, strlen(key),
4386                     value, strlen(value),
4387                     (time_t)0, (uint32_t)0);
4388   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
4389
4390   disconnected_server = memcached_server_get_last_disconnect(memc);
4391   test_false(disconnected_server);
4392
4393   /* With a non existing server */
4394   memcached_st *mine;
4395   memcached_server_st *servers;
4396
4397   const char *server_list= "localhost:9";
4398
4399   servers= memcached_servers_parse(server_list);
4400   test_true(servers);
4401   mine= memcached_create(NULL);
4402   rc= memcached_server_push(mine, servers);
4403   test_compare(MEMCACHED_SUCCESS, rc);
4404   memcached_server_list_free(servers);
4405   test_true(mine);
4406
4407   rc= memcached_set(mine, key, strlen(key),
4408                     value, strlen(value),
4409                     (time_t)0, (uint32_t)0);
4410   test_true(memcached_failed(rc));
4411
4412   disconnected_server= memcached_server_get_last_disconnect(mine);
4413   test_true_got(disconnected_server, memcached_strerror(mine, rc));
4414   test_compare(in_port_t(9), memcached_server_port(disconnected_server));
4415   test_false(strncmp(memcached_server_name(disconnected_server),"localhost",9));
4416
4417   memcached_quit(mine);
4418   memcached_free(mine);
4419
4420   return TEST_SUCCESS;
4421 }
4422
4423 test_return_t test_multiple_get_last_disconnect(memcached_st *)
4424 {
4425   const char *server_string= "--server=localhost:8888 --server=localhost:8889 --server=localhost:8890 --server=localhost:8891 --server=localhost:8892";
4426   char buffer[BUFSIZ];
4427
4428   test_compare(MEMCACHED_SUCCESS,
4429                libmemcached_check_configuration(server_string, strlen(server_string), buffer, sizeof(buffer)));
4430
4431   memcached_st *memc= memcached(server_string, strlen(server_string));
4432   test_true(memc);
4433
4434   // We will just use the error strings as our keys
4435   uint32_t counter= 100;
4436   while (--counter)
4437   {
4438     for (int x= int(MEMCACHED_SUCCESS); x < int(MEMCACHED_MAXIMUM_RETURN); ++x)
4439     {
4440       const char *msg=  memcached_strerror(memc, memcached_return_t(x));
4441       memcached_return_t ret= memcached_set(memc, msg, strlen(msg), NULL, 0, (time_t)0, (uint32_t)0);
4442       test_true_got((ret == MEMCACHED_CONNECTION_FAILURE or ret == MEMCACHED_SERVER_TEMPORARILY_DISABLED), memcached_last_error_message(memc));
4443
4444       const memcached_instance_st * disconnected_server= memcached_server_get_last_disconnect(memc);
4445       test_true(disconnected_server);
4446       test_strcmp("localhost", memcached_server_name(disconnected_server));
4447       test_true(memcached_server_port(disconnected_server) >= 8888 and memcached_server_port(disconnected_server) <= 8892);
4448
4449       if (random() % 2)
4450       {
4451         memcached_reset_last_disconnected_server(memc);
4452       }
4453     }
4454   }
4455
4456   memcached_free(memc);
4457
4458   return TEST_SUCCESS;
4459 }
4460
4461 test_return_t test_verbosity(memcached_st *memc)
4462 {
4463   memcached_verbosity(memc, 3);
4464
4465   return TEST_SUCCESS;
4466 }
4467
4468
4469 static memcached_return_t stat_printer(const memcached_instance_st * server,
4470                                        const char *key, size_t key_length,
4471                                        const char *value, size_t value_length,
4472                                        void *context)
4473 {
4474   (void)server;
4475   (void)context;
4476   (void)key;
4477   (void)key_length;
4478   (void)value;
4479   (void)value_length;
4480
4481   return MEMCACHED_SUCCESS;
4482 }
4483
4484 test_return_t memcached_stat_execute_test(memcached_st *memc)
4485 {
4486   memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
4487   test_compare(MEMCACHED_SUCCESS, rc);
4488
4489   test_compare(MEMCACHED_SUCCESS,
4490                memcached_stat_execute(memc, "slabs", stat_printer, NULL));
4491
4492   test_compare(MEMCACHED_SUCCESS,
4493                memcached_stat_execute(memc, "items", stat_printer, NULL));
4494
4495   test_compare(MEMCACHED_SUCCESS,
4496                memcached_stat_execute(memc, "sizes", stat_printer, NULL));
4497
4498   return TEST_SUCCESS;
4499 }
4500
4501 /*
4502  * This test ensures that the failure counter isn't incremented during
4503  * normal termination of the memcached instance.
4504  */
4505 test_return_t wrong_failure_counter_test(memcached_st *original_memc)
4506 {
4507   memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
4508
4509   /* Ensure that we are connected to the server by setting a value */
4510   memcached_return_t rc= memcached_set(memc,
4511                                        test_literal_param(__func__), // Key
4512                                        test_literal_param(__func__), // Value
4513                                        time_t(0), uint32_t(0));
4514   test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED);
4515
4516
4517   const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
4518
4519   /* The test is to see that the memcached_quit doesn't increase the
4520    * the server failure conter, so let's ensure that it is zero
4521    * before sending quit
4522  */
4523   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
4524
4525   memcached_quit(memc);
4526
4527   /* Verify that it memcached_quit didn't increment the failure counter
4528    * Please note that this isn't bullet proof, because an error could
4529    * occur...
4530  */
4531   test_zero(instance->server_failure_counter);
4532
4533   memcached_free(memc);
4534
4535   return TEST_SUCCESS;
4536 }
4537
4538 /*
4539  * This tests ensures expected disconnections (for some behavior changes
4540  * for instance) do not wrongly increase failure counter
4541  */
4542 test_return_t wrong_failure_counter_two_test(memcached_st *memc)
4543 {
4544   /* Set value to force connection to the server */
4545   const char *key= "marmotte";
4546   const char *value= "milka";
4547
4548   test_compare_hint(MEMCACHED_SUCCESS,
4549                     memcached_set(memc, key, strlen(key),
4550                                   value, strlen(value),
4551                                   (time_t)0, (uint32_t)0),
4552                     memcached_last_error_message(memc));
4553
4554
4555   /* put failure limit to 1 */
4556   test_compare(MEMCACHED_SUCCESS,
4557                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, true));
4558
4559   /* Put a retry timeout to effectively activate failure_limit effect */
4560   test_compare(MEMCACHED_SUCCESS,
4561                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, true));
4562
4563   /* change behavior that triggers memcached_quit()*/
4564   test_compare(MEMCACHED_SUCCESS,
4565                memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, true));
4566
4567
4568   /* Check if we still are connected */
4569   uint32_t flags;
4570   size_t string_length;
4571   memcached_return rc;
4572   char *string= memcached_get(memc, key, strlen(key),
4573                               &string_length, &flags, &rc);
4574
4575   test_compare_got(MEMCACHED_SUCCESS, rc, memcached_strerror(NULL, rc));
4576   test_true(string);
4577   free(string);
4578
4579   return TEST_SUCCESS;
4580 }
4581
4582 test_return_t regression_996813_TEST(memcached_st *)
4583 {
4584   memcached_st* memc= memcached_create(NULL);
4585
4586   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA));
4587   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1));
4588   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
4589   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
4590   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1));
4591   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 300));
4592   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 30));
4593
4594   // We will never connect to these servers
4595   in_port_t base_port= 11211;
4596   for (size_t x= 0; x < 17; x++)
4597   {
4598     test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.3.4", base_port +x));
4599   }
4600   test_compare(6U, memcached_generate_hash(memc, test_literal_param("SZ6hu0SHweFmpwpc0w2R")));
4601   test_compare(1U, memcached_generate_hash(memc, test_literal_param("SQCK9eiCf53YxHWnYA.o")));
4602   test_compare(9U, memcached_generate_hash(memc, test_literal_param("SUSDkGXuuZC9t9VhMwa.")));
4603   test_compare(0U, memcached_generate_hash(memc, test_literal_param("SnnqnJARfaCNT679iAF_")));
4604
4605   memcached_free(memc);
4606
4607   return TEST_SUCCESS;
4608 }
4609
4610
4611 /*
4612  * Test that ensures mget_execute does not end into recursive calls that finally fails
4613  */
4614 test_return_t regression_bug_490486(memcached_st *original_memc)
4615 {
4616
4617 #ifdef __APPLE__
4618   return TEST_SKIPPED; // My MAC can't handle this test
4619 #endif
4620
4621   test_skip(TEST_SUCCESS, pre_binary(original_memc));
4622
4623   /*
4624    * I only want to hit _one_ server so I know the number of requests I'm
4625    * sending in the pipeline.
4626  */
4627   memcached_st *memc= create_single_instance_memcached(original_memc, "--BINARY-PROTOCOL --POLL-TIMEOUT=1000 --REMOVE-FAILED-SERVERS=1 --RETRY-TIMEOUT=3600");
4628   test_true(memc);
4629
4630   keys_st keys(20480);
4631
4632   /* First add all of the items.. */
4633   char blob[1024]= { 0 };
4634   for (size_t x= 0; x < keys.size(); ++x)
4635   {
4636     memcached_return rc= memcached_set(memc,
4637                                        keys.key_at(x), keys.length_at(x),
4638                                        blob, sizeof(blob), 0, 0);
4639     test_true(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED); // MEMCACHED_TIMEOUT <-- hash been observed on OSX
4640   }
4641
4642   {
4643
4644     /* Try to get all of them with a large multiget */
4645     size_t counter= 0;
4646     memcached_execute_function callbacks[]= { &callback_counter };
4647     memcached_return_t rc= memcached_mget_execute(memc,
4648                                                   keys.keys_ptr(), keys.lengths_ptr(), keys.size(),
4649                                                   callbacks, &counter, 1);
4650     test_compare(MEMCACHED_SUCCESS, rc);
4651
4652     char* the_value= NULL;
4653     char the_key[MEMCACHED_MAX_KEY];
4654     size_t the_key_length;
4655     size_t the_value_length;
4656     uint32_t the_flags;
4657
4658     do {
4659       the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
4660
4661       if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
4662       {
4663         ++counter;
4664         free(the_value);
4665       }
4666
4667     } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
4668
4669
4670     test_compare(MEMCACHED_END, rc);
4671
4672     /* Verify that we got all of the items */
4673     test_compare(counter, keys.size());
4674   }
4675
4676   memcached_free(memc);
4677
4678   return TEST_SUCCESS;
4679 }
4680
4681 test_return_t regression_1021819_TEST(memcached_st *original)
4682 {
4683   memcached_st *memc= memcached_clone(NULL, original);
4684   test_true(memc);
4685
4686   test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 2000000), MEMCACHED_SUCCESS);
4687   test_compare(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 3000000), MEMCACHED_SUCCESS);
4688
4689   memcached_return_t rc;
4690
4691   memcached_get(memc,
4692                 test_literal_param(__func__),
4693                 NULL, NULL, &rc);
4694
4695   test_compare(rc, MEMCACHED_NOTFOUND);
4696
4697   memcached_free(memc);
4698
4699   return TEST_SUCCESS;
4700 }
4701
4702 test_return_t regression_bug_583031(memcached_st *)
4703 {
4704   memcached_st *memc= memcached_create(NULL);
4705   test_true(memc);
4706   test_compare(MEMCACHED_SUCCESS, memcached_server_add(memc, "10.2.251.4", 11211));
4707
4708   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 3000);
4709   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
4710   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
4711   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
4712   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
4713   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
4714
4715   memcached_return_t rc;
4716   size_t length;
4717   uint32_t flags;
4718
4719   const char *value= memcached_get(memc, "dsf", 3, &length, &flags, &rc);
4720   test_false(value);
4721   test_zero(length);
4722
4723   test_compare(MEMCACHED_TIMEOUT, memc);
4724
4725   memcached_free(memc);
4726
4727   return TEST_SUCCESS;
4728 }
4729
4730 test_return_t regression_bug_581030(memcached_st *)
4731 {
4732 #ifndef DEBUG
4733   memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
4734   test_false(local_stat);
4735
4736   memcached_stat_free(NULL, NULL);
4737 #endif
4738
4739   return TEST_SUCCESS;
4740 }
4741
4742 #define regression_bug_655423_COUNT 6000
4743 test_return_t regression_bug_655423(memcached_st *memc)
4744 {
4745   memcached_st *clone= memcached_clone(NULL, memc);
4746   memc= NULL; // Just to make sure it is not used
4747   test_true(clone);
4748   char payload[100];
4749
4750 #ifdef __APPLE__
4751   return TEST_SKIPPED;
4752 #endif
4753
4754   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
4755   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1));
4756   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1));
4757   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(clone, MEMCACHED_BEHAVIOR_IO_KEY_PREFETCH, 1));
4758
4759   memset(payload, int('x'), sizeof(payload));
4760
4761   keys_st keys(regression_bug_655423_COUNT);
4762
4763   for (size_t x= 0; x < keys.size(); x++)
4764   {
4765     test_compare(MEMCACHED_SUCCESS, memcached_set(clone,
4766                                                   keys.key_at(x),
4767                                                   keys.length_at(x),
4768                                                   payload, sizeof(payload), 0, 0));
4769   }
4770
4771   for (size_t x= 0; x < keys.size(); x++)
4772   {
4773     size_t value_length;
4774     memcached_return_t rc;
4775     char *value= memcached_get(clone,
4776                                keys.key_at(x),
4777                                keys.length_at(x),
4778                                &value_length, NULL, &rc);
4779
4780     if (rc == MEMCACHED_NOTFOUND)
4781     {
4782       test_false(value);
4783       test_zero(value_length);
4784       continue;
4785     }
4786
4787     test_compare(MEMCACHED_SUCCESS, rc);
4788     test_true(value);
4789     test_compare(100LLU, value_length);
4790     free(value);
4791   }
4792
4793   test_compare(MEMCACHED_SUCCESS,
4794                memcached_mget(clone,
4795                               keys.keys_ptr(), keys.lengths_ptr(),
4796                               keys.size()));
4797
4798   uint32_t count= 0;
4799   memcached_result_st *result= NULL;
4800   while ((result= memcached_fetch_result(clone, result, NULL)))
4801   {
4802     test_compare(size_t(100), memcached_result_length(result));
4803     count++;
4804   }
4805
4806   test_true(count > 100); // If we don't get back atleast this, something is up
4807
4808   memcached_free(clone);
4809
4810   return TEST_SUCCESS;
4811 }
4812
4813 /*
4814  * Test that ensures that buffered set to not trigger problems during io_flush
4815  */
4816 #define regression_bug_490520_COUNT 200480
4817 test_return_t regression_bug_490520(memcached_st *original_memc)
4818 {
4819   memcached_st* memc= create_single_instance_memcached(original_memc, NULL);
4820
4821   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK,1);
4822   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS,1);
4823   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
4824   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT,1);
4825   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
4826
4827   /* First add all of the items.. */
4828   char blob[3333] = {0};
4829   for (uint32_t x= 0; x < regression_bug_490520_COUNT; ++x)
4830   {
4831     char key[251];
4832     int key_length= snprintf(key, sizeof(key), "0200%u", x);
4833
4834     memcached_return rc= memcached_set(memc, key, key_length, blob, sizeof(blob), 0, 0);
4835     test_true_got(rc == MEMCACHED_SUCCESS or rc == MEMCACHED_BUFFERED, memcached_last_error_message(memc));
4836   }
4837
4838   memcached_free(memc);
4839
4840   return TEST_SUCCESS;
4841 }
4842
4843 test_return_t regression_1009493_TEST(memcached_st*)
4844 {
4845   memcached_st* memc= memcached_create(NULL);
4846   test_true(memc);
4847   test_compare(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, true));
4848
4849   memcached_st* clone= memcached_clone(NULL, memc);
4850   test_true(clone);
4851
4852   test_compare(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED),
4853                memcached_behavior_get(clone, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED));
4854
4855   memcached_free(memc);
4856   memcached_free(clone);
4857
4858   return TEST_SUCCESS;
4859 }
4860
4861 test_return_t regression_994772_TEST(memcached_st* memc)
4862 {
4863   test_skip(MEMCACHED_SUCCESS, memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1));
4864
4865   test_compare(MEMCACHED_SUCCESS,
4866                memcached_set(memc,
4867                              test_literal_param(__func__), // Key
4868                              test_literal_param(__func__), // Value
4869                              time_t(0), uint32_t(0)));
4870
4871   const char *keys[] = { __func__ };
4872   size_t key_length[]= { strlen(__func__) };
4873   test_compare(MEMCACHED_SUCCESS,
4874                memcached_mget(memc, keys, key_length, 1));
4875
4876   memcached_return_t rc;
4877   memcached_result_st *results= memcached_fetch_result(memc, NULL, &rc);
4878   test_true(results);
4879   test_compare(MEMCACHED_SUCCESS, rc);
4880
4881   test_strcmp(__func__, memcached_result_value(results));
4882   uint64_t cas_value= memcached_result_cas(results);
4883   test_true(cas_value);
4884
4885   char* take_value= memcached_result_take_value(results);
4886   test_strcmp(__func__, take_value);
4887   free(take_value);
4888
4889   memcached_result_free(results);
4890
4891   // Bad cas value, sanity check
4892   test_true(cas_value != 9999);
4893   test_compare(MEMCACHED_END,
4894                memcached_cas(memc,
4895                              test_literal_param(__func__), // Key
4896                              test_literal_param(__FILE__), // Value
4897                              time_t(0), uint32_t(0), 9999));
4898
4899   test_compare(MEMCACHED_SUCCESS, memcached_set(memc,
4900                                                 "different", strlen("different"), // Key
4901                                                 test_literal_param(__FILE__), // Value
4902                                                 time_t(0), uint32_t(0)));
4903
4904   return TEST_SUCCESS;
4905 }
4906
4907 test_return_t regression_bug_854604(memcached_st *)
4908 {
4909   char buffer[1024];
4910
4911   test_compare(MEMCACHED_INVALID_ARGUMENTS, libmemcached_check_configuration(0, 0, buffer, 0));
4912
4913   test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 0));
4914
4915   test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 1));
4916   test_compare(buffer[0], 0);
4917
4918   test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, 10));
4919   test_true(strlen(buffer));
4920
4921   test_compare(MEMCACHED_PARSE_ERROR, libmemcached_check_configuration(test_literal_param("syntax error"), buffer, sizeof(buffer)));
4922   test_true(strlen(buffer));
4923
4924   return TEST_SUCCESS;
4925 }
4926
4927 static void die_message(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
4928 {
4929   fprintf(stderr, "Iteration #%u: ", it);
4930
4931   if (error == MEMCACHED_ERRNO)
4932   {
4933     fprintf(stderr, "system error %d from %s: %s\n",
4934             errno, what, strerror(errno));
4935   }
4936   else
4937   {
4938     fprintf(stderr, "error %d from %s: %s\n", error, what,
4939             memcached_strerror(mc, error));
4940   }
4941 }
4942
4943 #define TEST_CONSTANT_CREATION 200
4944
4945 test_return_t regression_bug_(memcached_st *memc)
4946 {
4947   const char *remote_server;
4948   (void)memc;
4949
4950   if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
4951   {
4952     return TEST_SKIPPED;
4953   }
4954
4955   for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
4956   {
4957     memcached_st* mc= memcached_create(NULL);
4958     memcached_return rc;
4959
4960     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
4961     if (rc != MEMCACHED_SUCCESS)
4962     {
4963       die_message(mc, rc, "memcached_behavior_set", x);
4964     }
4965
4966     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
4967     if (rc != MEMCACHED_SUCCESS)
4968     {
4969       die_message(mc, rc, "memcached_behavior_set", x);
4970     }
4971
4972     rc= memcached_server_add(mc, remote_server, 0);
4973     if (rc != MEMCACHED_SUCCESS)
4974     {
4975       die_message(mc, rc, "memcached_server_add", x);
4976     }
4977
4978     const char *set_key= "akey";
4979     const size_t set_key_len= strlen(set_key);
4980     const char *set_value= "a value";
4981     const size_t set_value_len= strlen(set_value);
4982
4983     if (rc == MEMCACHED_SUCCESS)
4984     {
4985       if (x > 0)
4986       {
4987         size_t get_value_len;
4988         char *get_value;
4989         uint32_t get_value_flags;
4990
4991         get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
4992                                  &get_value_flags, &rc);
4993         if (rc != MEMCACHED_SUCCESS)
4994         {
4995           die_message(mc, rc, "memcached_get", x);
4996         }
4997         else
4998         {
4999
5000           if (x != 0 &&
5001               (get_value_len != set_value_len
5002                || 0!=strncmp(get_value, set_value, get_value_len)))
5003           {
5004             fprintf(stderr, "Values don't match?\n");
5005             rc= MEMCACHED_FAILURE;
5006           }
5007           free(get_value);
5008         }
5009       }
5010
5011       rc= memcached_set(mc,
5012                         set_key, set_key_len,
5013                         set_value, set_value_len,
5014                         0, /* time */
5015                         0  /* flags */
5016                        );
5017       if (rc != MEMCACHED_SUCCESS)
5018       {
5019         die_message(mc, rc, "memcached_set", x);
5020       }
5021     }
5022
5023     memcached_quit(mc);
5024     memcached_free(mc);
5025
5026     if (rc != MEMCACHED_SUCCESS)
5027     {
5028       break;
5029     }
5030   }
5031
5032   return TEST_SUCCESS;
5033 }
5034
5035 test_return_t kill_HUP_TEST(memcached_st *original_memc)
5036 {
5037   memcached_st *memc= create_single_instance_memcached(original_memc, 0);
5038   test_true(memc);
5039
5040   const memcached_instance_st * instance= memcached_server_instance_by_position(memc, 0);
5041
5042   pid_t pid;
5043   test_true((pid= libmemcached_util_getpid(memcached_server_name(instance),
5044                                            memcached_server_port(instance), NULL)) > -1);
5045
5046
5047   test_compare(MEMCACHED_SUCCESS,
5048                memcached_set(memc,
5049                              test_literal_param(__func__), // Keys
5050                              test_literal_param(__func__), // Values
5051                              0, 0));
5052   test_true_got(kill(pid, SIGHUP) == 0, strerror(errno));
5053
5054   memcached_return_t ret= memcached_set(memc,
5055                                         test_literal_param(__func__), // Keys
5056                                         test_literal_param(__func__), // Values
5057                                         0, 0);
5058   test_compare(ret, memc);
5059   test_compare(MEMCACHED_CONNECTION_FAILURE, memc);
5060
5061   memcached_free(memc);
5062
5063   return TEST_SUCCESS;
5064 }