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