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