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