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