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