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   const char *keys= "036790384900";
2490   size_t key_length=  strlen(keys);
2491   char return_key[MEMCACHED_MAX_KEY];
2492   size_t return_key_length;
2493   char *value;
2494   size_t value_length;
2495   uint32_t flags;
2496   char *insert_data= new (std::nothrow) char[VALUE_SIZE_BUG5];
2497
2498   for (unsigned int x= 0; x < VALUE_SIZE_BUG5; x++)
2499     insert_data[x]= (signed char)rand();
2500
2501   memcached_flush(memc, 0);
2502
2503   flags= 245;
2504   memcached_return_t rc= memcached_set(memc, keys, key_length,
2505                                        insert_data, VALUE_SIZE_BUG5,
2506                                        (time_t)0, flags);
2507   test_true(rc == MEMCACHED_SUCCESS);
2508
2509   flags= 0;
2510   value= memcached_get(memc, keys, key_length,
2511                         &value_length, &flags, &rc);
2512   test_true(flags == 245);
2513   test_true(value);
2514   free(value);
2515
2516   rc= memcached_mget(memc, &keys, &key_length, 1);
2517
2518   flags= 0;
2519   value= memcached_fetch(memc, return_key, &return_key_length,
2520                          &value_length, &flags, &rc);
2521   test_compare(245, flags);
2522   test_true(value);
2523   free(value);
2524   delete [] insert_data;
2525
2526
2527   return TEST_SUCCESS;
2528 }
2529
2530 static test_return_t user_supplied_bug9(memcached_st *memc)
2531 {
2532   const char *keys[]= {"UDATA:edevil@sapo.pt", "fudge&*@#", "for^#@&$not"};
2533   size_t key_length[3];
2534   uint32_t flags;
2535   unsigned count= 0;
2536
2537   char return_key[MEMCACHED_MAX_KEY];
2538   size_t return_key_length;
2539   char *return_value;
2540   size_t return_value_length;
2541
2542
2543   key_length[0]= strlen("UDATA:edevil@sapo.pt");
2544   key_length[1]= strlen("fudge&*@#");
2545   key_length[2]= strlen("for^#@&$not");
2546
2547
2548   for (unsigned int x= 0; x < 3; x++)
2549   {
2550     memcached_return_t rc;
2551     rc= memcached_set(memc, keys[x], key_length[x],
2552                       keys[x], key_length[x],
2553                       (time_t)50, (uint32_t)9);
2554     test_true(rc == MEMCACHED_SUCCESS);
2555   }
2556
2557   memcached_return_t rc= memcached_mget(memc, keys, key_length, 3);
2558   test_true(rc == MEMCACHED_SUCCESS);
2559
2560   /* We need to empty the server before continueing test */
2561   while ((return_value= memcached_fetch(memc, return_key, &return_key_length,
2562                       &return_value_length, &flags, &rc)) != NULL)
2563   {
2564     test_true(return_value);
2565     free(return_value);
2566     count++;
2567   }
2568   test_true(count == 3);
2569
2570   return TEST_SUCCESS;
2571 }
2572
2573 /* We are testing with aggressive timeout to get failures */
2574 static test_return_t user_supplied_bug10(memcached_st *memc)
2575 {
2576   const char *key= "foo";
2577   char *value;
2578   size_t value_length= 512;
2579   unsigned int x;
2580   size_t key_len= 3;
2581   unsigned int set= 1;
2582   memcached_st *mclone= memcached_clone(NULL, memc);
2583   int32_t timeout;
2584
2585   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2586   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2587   timeout= 2;
2588   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2589                          (uint64_t)timeout);
2590
2591   value = (char*)malloc(value_length * sizeof(char));
2592
2593   for (x= 0; x < value_length; x++)
2594     value[x]= (char) (x % 127);
2595
2596   for (x= 1; x <= 100000; ++x)
2597   {
2598     memcached_return_t rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2599
2600     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_WRITE_FAILURE ||
2601            rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT);
2602
2603     if (rc == MEMCACHED_WRITE_FAILURE || rc == MEMCACHED_TIMEOUT)
2604       x--;
2605   }
2606
2607   free(value);
2608   memcached_free(mclone);
2609
2610   return TEST_SUCCESS;
2611 }
2612
2613 /*
2614   We are looking failures in the async protocol
2615 */
2616 static test_return_t user_supplied_bug11(memcached_st *memc)
2617 {
2618   const char *key= "foo";
2619   char *value;
2620   size_t value_length= 512;
2621   unsigned int x;
2622   size_t key_len= 3;
2623   memcached_return_t rc;
2624   unsigned int set= 1;
2625   int32_t timeout;
2626   memcached_st *mclone= memcached_clone(NULL, memc);
2627
2628   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_NO_BLOCK, set);
2629   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_TCP_NODELAY, set);
2630   timeout= -1;
2631   memcached_behavior_set(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT,
2632                          (size_t)timeout);
2633
2634   timeout= (int32_t)memcached_behavior_get(mclone, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
2635
2636   test_true(timeout == -1);
2637
2638   value = (char*)malloc(value_length * sizeof(char));
2639
2640   for (x= 0; x < value_length; x++)
2641     value[x]= (char) (x % 127);
2642
2643   for (x= 1; x <= 100000; ++x)
2644   {
2645     rc= memcached_set(mclone, key, key_len,value, value_length, 0, 0);
2646   }
2647
2648   free(value);
2649   memcached_free(mclone);
2650
2651   return TEST_SUCCESS;
2652 }
2653
2654 /*
2655   Bug found where incr was not returning MEMCACHED_NOTFOUND when object did not exist.
2656 */
2657 static test_return_t user_supplied_bug12(memcached_st *memc)
2658 {
2659   memcached_return_t rc;
2660   uint32_t flags;
2661   size_t value_length;
2662   char *value;
2663   uint64_t number_value;
2664
2665   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2666                         &value_length, &flags, &rc);
2667   test_true(value == NULL);
2668   test_true(rc == MEMCACHED_NOTFOUND);
2669
2670   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2671                           1, &number_value);
2672
2673   test_true(value == NULL);
2674   /* The binary protocol will set the key if it doesn't exist */
2675   if (memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1)
2676   {
2677     test_true(rc == MEMCACHED_SUCCESS);
2678   }
2679   else
2680   {
2681     test_true(rc == MEMCACHED_NOTFOUND);
2682   }
2683
2684   rc= memcached_set(memc, "autoincrement", strlen("autoincrement"), "1", 1, 0, 0);
2685
2686   value= memcached_get(memc, "autoincrement", strlen("autoincrement"),
2687                         &value_length, &flags, &rc);
2688   test_true(value);
2689   test_true(rc == MEMCACHED_SUCCESS);
2690   free(value);
2691
2692   rc= memcached_increment(memc, "autoincrement", strlen("autoincrement"),
2693                           1, &number_value);
2694   test_true(number_value == 2);
2695   test_true(rc == MEMCACHED_SUCCESS);
2696
2697   return TEST_SUCCESS;
2698 }
2699
2700 /*
2701   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2702   set key34567890 0 0 8169 \r\n is sent followed by buffer of size 8169, followed by 8169
2703  */
2704 static test_return_t user_supplied_bug13(memcached_st *memc)
2705 {
2706   char key[] = "key34567890";
2707   memcached_return_t rc;
2708   size_t overflowSize;
2709
2710   char commandFirst[]= "set key34567890 0 0 ";
2711   char commandLast[] = " \r\n"; /* first line of command sent to server */
2712   size_t commandLength;
2713   size_t testSize;
2714
2715   commandLength = strlen(commandFirst) + strlen(commandLast) + 4; /* 4 is number of characters in size, probably 8196 */
2716
2717   overflowSize = MEMCACHED_MAX_BUFFER - commandLength;
2718
2719   for (testSize= overflowSize - 1; testSize < overflowSize + 1; testSize++)
2720   {
2721     char *overflow= new (std::nothrow) char[testSize];
2722     test_true(overflow);
2723
2724     memset(overflow, 'x', testSize);
2725     rc= memcached_set(memc, key, strlen(key),
2726                       overflow, testSize, 0, 0);
2727     test_true(rc == MEMCACHED_SUCCESS);
2728     delete overflow;
2729   }
2730
2731   return TEST_SUCCESS;
2732 }
2733
2734
2735 /*
2736   Test values of many different sizes
2737   Bug found where command total one more than MEMCACHED_MAX_BUFFER
2738   set key34567890 0 0 8169 \r\n
2739   is sent followed by buffer of size 8169, followed by 8169
2740  */
2741 static test_return_t user_supplied_bug14(memcached_st *memc)
2742 {
2743   size_t setter= 1;
2744   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, setter);
2745   memcached_return_t rc;
2746   const char *key= "foo";
2747   char *value;
2748   size_t value_length= 18000;
2749   char *string;
2750   size_t string_length;
2751   uint32_t flags;
2752   unsigned int x;
2753   size_t current_length;
2754
2755   value = (char*)malloc(value_length);
2756   test_true(value);
2757
2758   for (x= 0; x < value_length; x++)
2759     value[x] = (char) (x % 127);
2760
2761   for (current_length= 0; current_length < value_length; current_length++)
2762   {
2763     rc= memcached_set(memc, key, strlen(key),
2764                       value, current_length,
2765                       (time_t)0, (uint32_t)0);
2766     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
2767
2768     string= memcached_get(memc, key, strlen(key),
2769                           &string_length, &flags, &rc);
2770
2771     test_true(rc == MEMCACHED_SUCCESS);
2772     test_true(string_length == current_length);
2773     test_true(!memcmp(string, value, string_length));
2774
2775     free(string);
2776   }
2777
2778   free(value);
2779
2780   return TEST_SUCCESS;
2781 }
2782
2783 /*
2784   Look for zero length value problems
2785   */
2786 static test_return_t user_supplied_bug15(memcached_st *memc)
2787 {
2788   uint32_t x;
2789   memcached_return_t rc;
2790   const char *key= "mykey";
2791   char *value;
2792   size_t length;
2793   uint32_t flags;
2794
2795   for (x= 0; x < 2; x++)
2796   {
2797     rc= memcached_set(memc, key, strlen(key),
2798                       NULL, 0,
2799                       (time_t)0, (uint32_t)0);
2800
2801     test_true(rc == MEMCACHED_SUCCESS);
2802
2803     value= memcached_get(memc, key, strlen(key),
2804                          &length, &flags, &rc);
2805
2806     test_true(rc == MEMCACHED_SUCCESS);
2807     test_true(value == NULL);
2808     test_true(length == 0);
2809     test_true(flags == 0);
2810
2811     value= memcached_get(memc, key, strlen(key),
2812                          &length, &flags, &rc);
2813
2814     test_true(rc == MEMCACHED_SUCCESS);
2815     test_true(value == NULL);
2816     test_true(length == 0);
2817     test_true(flags == 0);
2818   }
2819
2820   return TEST_SUCCESS;
2821 }
2822
2823 /* Check the return sizes on FLAGS to make sure it stores 32bit unsigned values correctly */
2824 static test_return_t user_supplied_bug16(memcached_st *memc)
2825 {
2826   memcached_return_t rc;
2827   const char *key= "mykey";
2828   char *value;
2829   size_t length;
2830   uint32_t flags;
2831
2832   rc= memcached_set(memc, key, strlen(key),
2833                     NULL, 0,
2834                     (time_t)0, UINT32_MAX);
2835
2836   test_true(rc == MEMCACHED_SUCCESS);
2837
2838   value= memcached_get(memc, key, strlen(key),
2839                        &length, &flags, &rc);
2840
2841   test_true(rc == MEMCACHED_SUCCESS);
2842   test_true(value == NULL);
2843   test_true(length == 0);
2844   test_true(flags == UINT32_MAX);
2845
2846   return TEST_SUCCESS;
2847 }
2848
2849 #if !defined(__sun) && !defined(__OpenBSD__)
2850 /* Check the validity of chinese key*/
2851 static test_return_t user_supplied_bug17(memcached_st *memc)
2852 {
2853     memcached_return_t rc;
2854     const char *key= "豆瓣";
2855     const char *value="我们在炎热抑郁的夏天无法停止豆瓣";
2856     char *value2;
2857     size_t length;
2858     uint32_t flags;
2859
2860     rc= memcached_set(memc, key, strlen(key),
2861             value, strlen(value),
2862             (time_t)0, 0);
2863
2864     test_true(rc == MEMCACHED_SUCCESS);
2865
2866     value2= memcached_get(memc, key, strlen(key),
2867             &length, &flags, &rc);
2868
2869     test_true(length==strlen(value));
2870     test_true(rc == MEMCACHED_SUCCESS);
2871     test_true(memcmp(value, value2, length)==0);
2872     free(value2);
2873
2874     return TEST_SUCCESS;
2875 }
2876 #endif
2877
2878 /*
2879   From Andrei on IRC
2880 */
2881
2882 static test_return_t user_supplied_bug19(memcached_st *not_used)
2883 {
2884   memcached_st *memc;
2885   const memcached_server_st *server;
2886   memcached_return_t res;
2887
2888   (void)not_used;
2889
2890   memc= memcached_create(NULL);
2891   memcached_server_add_with_weight(memc, "localhost", 11311, 100);
2892   memcached_server_add_with_weight(memc, "localhost", 11312, 100);
2893
2894   server= memcached_server_by_key(memc, "a", 1, &res);
2895
2896   memcached_free(memc);
2897
2898   return TEST_SUCCESS;
2899 }
2900
2901 /* CAS test from Andei */
2902 static test_return_t user_supplied_bug20(memcached_st *memc)
2903 {
2904   memcached_return_t status;
2905   memcached_result_st *result, result_obj;
2906   const char *key = "abc";
2907   size_t key_len = strlen("abc");
2908   const char *value = "foobar";
2909   size_t value_len = strlen(value);
2910
2911   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
2912
2913   status = memcached_set(memc, key, key_len, value, value_len, (time_t)0, (uint32_t)0);
2914   test_true(status == MEMCACHED_SUCCESS);
2915
2916   status = memcached_mget(memc, &key, &key_len, 1);
2917   test_true(status == MEMCACHED_SUCCESS);
2918
2919   result= memcached_result_create(memc, &result_obj);
2920   test_true(result);
2921
2922   memcached_result_create(memc, &result_obj);
2923   result= memcached_fetch_result(memc, &result_obj, &status);
2924
2925   test_true(result);
2926   test_true(status == MEMCACHED_SUCCESS);
2927
2928   memcached_result_free(result);
2929
2930   return TEST_SUCCESS;
2931 }
2932
2933 #include "ketama_test_cases.h"
2934 static test_return_t user_supplied_bug18(memcached_st *trash)
2935 {
2936   memcached_return_t rc;
2937   uint64_t value;
2938   int x;
2939   memcached_server_st *server_pool;
2940   memcached_st *memc;
2941
2942   (void)trash;
2943
2944   memc= memcached_create(NULL);
2945   test_true(memc);
2946
2947   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
2948   test_true(rc == MEMCACHED_SUCCESS);
2949
2950   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
2951   test_true(value == 1);
2952
2953   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
2954   test_true(rc == MEMCACHED_SUCCESS);
2955
2956   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
2957   test_true(value == MEMCACHED_HASH_MD5);
2958
2959   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");
2960   memcached_server_push(memc, server_pool);
2961
2962   /* verify that the server list was parsed okay. */
2963   test_true(memcached_server_count(memc) == 8);
2964   test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
2965   test_true(server_pool[0].port == 11211);
2966   test_true(server_pool[0].weight == 600);
2967   test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
2968   test_true(server_pool[2].port == 11211);
2969   test_true(server_pool[2].weight == 200);
2970   test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
2971   test_true(server_pool[7].port == 11211);
2972   test_true(server_pool[7].weight == 100);
2973
2974   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
2975    * us test the boundary wraparound.
2976    */
2977   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
2978
2979   /* verify the standard ketama set. */
2980   for (x= 0; x < 99; x++)
2981   {
2982     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
2983
2984     memcached_server_instance_st instance=
2985       memcached_server_instance_by_position(memc, server_idx);
2986
2987     const char *hostname = memcached_server_name(instance);
2988     test_strcmp(hostname, ketama_test_cases[x].server);
2989   }
2990
2991   memcached_server_list_free(server_pool);
2992   memcached_free(memc);
2993
2994   return TEST_SUCCESS;
2995 }
2996
2997 /* Large mget() of missing keys with binary proto
2998  *
2999  * If many binary quiet commands (such as getq's in an mget) fill the output
3000  * buffer and the server chooses not to respond, memcached_flush hangs. See
3001  * http://lists.tangent.org/pipermail/libmemcached/2009-August/000918.html
3002  */
3003
3004 /* sighandler_t function that always asserts false */
3005 static void fail(int unused)
3006 {
3007   (void)unused;
3008   assert(0);
3009 }
3010
3011
3012 static test_return_t _user_supplied_bug21(memcached_st* memc, size_t key_count)
3013 {
3014 #ifdef WIN32
3015   (void)memc;
3016   (void)key_count;
3017   return TEST_SKIPPED;
3018 #else
3019   memcached_return_t rc;
3020   unsigned int x;
3021   char **keys;
3022   size_t* key_lengths;
3023   void (*oldalarm)(int);
3024   memcached_st *memc_clone;
3025
3026   memc_clone= memcached_clone(NULL, memc);
3027   test_true(memc_clone);
3028
3029   /* only binproto uses getq for mget */
3030   memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3031
3032   /* empty the cache to ensure misses (hence non-responses) */
3033   rc= memcached_flush(memc_clone, 0);
3034   test_true(rc == MEMCACHED_SUCCESS);
3035
3036   key_lengths= new (std::nothrow) size_t[key_count];
3037   test_true(key_lengths);
3038   keys= static_cast<char **>(calloc(key_count, sizeof(char *)));
3039   test_true(keys);
3040   for (x= 0; x < key_count; x++)
3041   {
3042     char buffer[30];
3043
3044     snprintf(buffer, 30, "%u", x);
3045     keys[x]= strdup(buffer);
3046     key_lengths[x]= strlen(keys[x]);
3047   }
3048
3049   oldalarm= signal(SIGALRM, fail);
3050   alarm(5);
3051
3052   rc= memcached_mget(memc_clone, (const char **)keys, key_lengths, key_count);
3053   test_true(rc == MEMCACHED_SUCCESS);
3054
3055   alarm(0);
3056   signal(SIGALRM, oldalarm);
3057
3058   size_t keys_returned;
3059   test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3060
3061   for (x= 0; x < key_count; x++)
3062     free(keys[x]);
3063   free(keys);
3064   delete key_lengths;
3065
3066   memcached_free(memc_clone);
3067
3068   return TEST_SUCCESS;
3069 #endif
3070 }
3071
3072 static test_return_t user_supplied_bug21(memcached_st *memc)
3073 {
3074   test_return_t test_rc;
3075   test_rc= pre_binary(memc);
3076
3077   if (test_rc != TEST_SUCCESS)
3078     return test_rc;
3079
3080   test_return_t rc;
3081
3082   /* should work as of r580 */
3083   rc= _user_supplied_bug21(memc, 10);
3084   test_true(rc == TEST_SUCCESS);
3085
3086   /* should fail as of r580 */
3087   rc= _user_supplied_bug21(memc, 1000);
3088   test_true(rc == TEST_SUCCESS);
3089
3090   return TEST_SUCCESS;
3091 }
3092
3093 static test_return_t auto_eject_hosts(memcached_st *trash)
3094 {
3095   (void) trash;
3096   memcached_server_instance_st instance;
3097
3098   memcached_return_t rc;
3099   memcached_st *memc= memcached_create(NULL);
3100   test_true(memc);
3101
3102   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3103   test_true(rc == MEMCACHED_SUCCESS);
3104
3105   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3106   test_true(value == 1);
3107
3108   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3109   test_true(rc == MEMCACHED_SUCCESS);
3110
3111   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3112   test_true(value == MEMCACHED_HASH_MD5);
3113
3114     /* server should be removed when in delay */
3115   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS, 1);
3116   test_true(rc == MEMCACHED_SUCCESS);
3117
3118   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_AUTO_EJECT_HOSTS);
3119   test_true(value == 1);
3120
3121   memcached_server_st *server_pool;
3122   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");
3123   memcached_server_push(memc, server_pool);
3124
3125   /* verify that the server list was parsed okay. */
3126   test_true(memcached_server_count(memc) == 8);
3127   test_true(strcmp(server_pool[0].hostname, "10.0.1.1") == 0);
3128   test_true(server_pool[0].port == 11211);
3129   test_true(server_pool[0].weight == 600);
3130   test_true(strcmp(server_pool[2].hostname, "10.0.1.3") == 0);
3131   test_true(server_pool[2].port == 11211);
3132   test_true(server_pool[2].weight == 200);
3133   test_true(strcmp(server_pool[7].hostname, "10.0.1.8") == 0);
3134   test_true(server_pool[7].port == 11211);
3135   test_true(server_pool[7].weight == 100);
3136
3137   instance= memcached_server_instance_by_position(memc, 2);
3138   ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) + 15;
3139   memc->ketama.next_distribution_rebuild= time(NULL) - 1;
3140
3141   /*
3142     This would not work if there were only two hosts.
3143   */
3144   for (size_t x= 0; x < 99; x++)
3145   {
3146     memcached_autoeject(memc);
3147     uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
3148     test_true(server_idx != 2);
3149   }
3150
3151   /* and re-added when it's back. */
3152   ((memcached_server_write_instance_st)instance)->next_retry = time(NULL) - 1;
3153   memc->ketama.next_distribution_rebuild= time(NULL) - 1;
3154   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION,
3155                          memc->distribution);
3156   for (size_t x= 0; x < 99; x++)
3157   {
3158     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
3159     // We re-use instance from above.
3160     instance=
3161       memcached_server_instance_by_position(memc, server_idx);
3162     const char *hostname = memcached_server_name(instance);
3163     test_true(strcmp(hostname, ketama_test_cases[x].server) == 0);
3164   }
3165
3166   memcached_server_list_free(server_pool);
3167   memcached_free(memc);
3168
3169   return TEST_SUCCESS;
3170 }
3171
3172 static test_return_t output_ketama_weighted_keys(memcached_st *trash)
3173 {
3174   (void) trash;
3175
3176   memcached_return_t rc;
3177   memcached_st *memc= memcached_create(NULL);
3178   test_true(memc);
3179
3180
3181   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3182   test_true(rc == MEMCACHED_SUCCESS);
3183
3184   uint64_t value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3185   test_true(value == 1);
3186
3187   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3188   test_true(rc == MEMCACHED_SUCCESS);
3189
3190   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3191   test_true(value == MEMCACHED_HASH_MD5);
3192
3193
3194   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
3195
3196   memcached_server_st *server_pool;
3197   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");
3198   memcached_server_push(memc, server_pool);
3199
3200   // @todo this needs to be refactored to actually test something.
3201 #if 0
3202   FILE *fp;
3203   if ((fp = fopen("ketama_keys.txt", "w")))
3204   {
3205     // noop
3206   } else {
3207     printf("cannot write to file ketama_keys.txt");
3208     return TEST_FAILURE;
3209   }
3210
3211   for (int x= 0; x < 10000; x++)
3212   {
3213     char key[10];
3214     snprintf(key, sizeof(key), "%d", x);
3215
3216     uint32_t server_idx = memcached_generate_hash(memc, key, strlen(key));
3217     char *hostname = memc->hosts[server_idx].hostname;
3218     in_port_t port = memc->hosts[server_idx].port;
3219     fprintf(fp, "key %s is on host /%s:%u\n", key, hostname, port);
3220     memcached_server_instance_st instance=
3221       memcached_server_instance_by_position(memc, host_index);
3222   }
3223   fclose(fp);
3224 #endif
3225   memcached_server_list_free(server_pool);
3226   memcached_free(memc);
3227
3228   return TEST_SUCCESS;
3229 }
3230
3231
3232 static test_return_t result_static(memcached_st *memc)
3233 {
3234   memcached_result_st result;
3235   memcached_result_st *result_ptr;
3236
3237   result_ptr= memcached_result_create(memc, &result);
3238   test_true(result.options.is_allocated == false);
3239   test_true(memcached_is_initialized(&result) == true);
3240   test_true(result_ptr);
3241   test_true(result_ptr == &result);
3242
3243   memcached_result_free(&result);
3244
3245   test_true(result.options.is_allocated == false);
3246   test_true(memcached_is_initialized(&result) == false);
3247
3248   return TEST_SUCCESS;
3249 }
3250
3251 static test_return_t result_alloc(memcached_st *memc)
3252 {
3253   memcached_result_st *result_ptr;
3254
3255   result_ptr= memcached_result_create(memc, NULL);
3256   test_true(result_ptr);
3257   test_true(result_ptr->options.is_allocated == true);
3258   test_true(memcached_is_initialized(result_ptr) == true);
3259   memcached_result_free(result_ptr);
3260
3261   return TEST_SUCCESS;
3262 }
3263
3264 static test_return_t cleanup_pairs(memcached_st *memc)
3265 {
3266   (void)memc;
3267   pairs_free(global_pairs);
3268
3269   return TEST_SUCCESS;
3270 }
3271
3272 static test_return_t generate_pairs(memcached_st *memc)
3273 {
3274   (void)memc;
3275   global_pairs= pairs_generate(GLOBAL_COUNT, 400);
3276   global_count= GLOBAL_COUNT;
3277
3278   for (size_t x= 0; x < global_count; x++)
3279   {
3280     global_keys[x]= global_pairs[x].key;
3281     global_keys_length[x]=  global_pairs[x].key_length;
3282   }
3283
3284   return TEST_SUCCESS;
3285 }
3286
3287 static test_return_t generate_large_pairs(memcached_st *memc)
3288 {
3289   (void)memc;
3290   global_pairs= pairs_generate(GLOBAL2_COUNT, MEMCACHED_MAX_BUFFER+10);
3291   global_count= GLOBAL2_COUNT;
3292
3293   for (size_t x= 0; x < global_count; x++)
3294   {
3295     global_keys[x]= global_pairs[x].key;
3296     global_keys_length[x]=  global_pairs[x].key_length;
3297   }
3298
3299   return TEST_SUCCESS;
3300 }
3301
3302 static test_return_t generate_data(memcached_st *memc)
3303 {
3304   unsigned int check_execute= execute_set(memc, global_pairs, global_count);
3305
3306   test_true(check_execute == global_count);
3307
3308   return TEST_SUCCESS;
3309 }
3310
3311 static test_return_t generate_data_with_stats(memcached_st *memc)
3312 {
3313   memcached_stat_st *stat_p;
3314   memcached_return_t rc;
3315   uint32_t host_index= 0;
3316   unsigned int check_execute= execute_set(memc, global_pairs, global_count);
3317
3318   test_true(check_execute == global_count);
3319
3320   //TODO: hosts used size stats
3321   stat_p= memcached_stat(memc, NULL, &rc);
3322   test_true(stat_p);
3323
3324   for (host_index= 0; host_index < SERVERS_TO_CREATE; host_index++)
3325   {
3326     /* This test was changes so that "make test" would work properlly */
3327 #ifdef DEBUG
3328     memcached_server_instance_st instance=
3329       memcached_server_instance_by_position(memc, host_index);
3330
3331     printf("\nserver %u|%s|%u bytes: %llu\n", host_index, instance->hostname, instance->port, (unsigned long long)(stat_p + host_index)->bytes);
3332 #endif
3333     test_true((unsigned long long)(stat_p + host_index)->bytes);
3334   }
3335
3336   memcached_stat_free(NULL, stat_p);
3337
3338   return TEST_SUCCESS;
3339 }
3340 static test_return_t generate_buffer_data(memcached_st *memc)
3341 {
3342   size_t latch= 0;
3343
3344   latch= 1;
3345   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3346   generate_data(memc);
3347
3348   return TEST_SUCCESS;
3349 }
3350
3351 static test_return_t get_read_count(memcached_st *memc)
3352 {
3353   memcached_return_t rc;
3354   memcached_st *memc_clone;
3355
3356   memc_clone= memcached_clone(NULL, memc);
3357   test_true(memc_clone);
3358
3359   memcached_server_add_with_weight(memc_clone, "localhost", 6666, 0);
3360
3361   {
3362     char *return_value;
3363     size_t return_value_length;
3364     uint32_t flags;
3365     uint32_t count;
3366
3367     for (size_t x= count= 0; x < global_count; x++)
3368     {
3369       return_value= memcached_get(memc_clone, global_keys[x], global_keys_length[x],
3370                                   &return_value_length, &flags, &rc);
3371       if (rc == MEMCACHED_SUCCESS)
3372       {
3373         count++;
3374         if (return_value)
3375           free(return_value);
3376       }
3377     }
3378   }
3379
3380   memcached_free(memc_clone);
3381
3382   return TEST_SUCCESS;
3383 }
3384
3385 static test_return_t get_read(memcached_st *memc)
3386 {
3387   memcached_return_t rc;
3388
3389   {
3390     char *return_value;
3391     size_t return_value_length;
3392     uint32_t flags;
3393
3394     for (size_t x= 0; x < global_count; x++)
3395     {
3396       return_value= memcached_get(memc, global_keys[x], global_keys_length[x],
3397                                   &return_value_length, &flags, &rc);
3398       /*
3399       test_true(return_value);
3400       test_true(rc == MEMCACHED_SUCCESS);
3401     */
3402       if (rc == MEMCACHED_SUCCESS && return_value)
3403         free(return_value);
3404     }
3405   }
3406
3407   return TEST_SUCCESS;
3408 }
3409
3410 static test_return_t mget_read(memcached_st *memc)
3411 {
3412   memcached_return_t rc;
3413
3414   if (! libmemcached_util_version_check(memc, 1, 4, 4))
3415     return TEST_SKIPPED;
3416
3417   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3418
3419   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3420
3421   // Go fetch the keys and test to see if all of them were returned
3422   {
3423     size_t keys_returned;
3424     test_true(fetch_all_results(memc, &keys_returned) == TEST_SUCCESS);
3425     char buffer[30];
3426     snprintf(buffer, sizeof(buffer), "%lu", (unsigned long)keys_returned);
3427     test_true_got(global_count == keys_returned, buffer);
3428   }
3429
3430
3431   return TEST_SUCCESS;
3432 }
3433
3434 static test_return_t mget_read_result(memcached_st *memc)
3435 {
3436   memcached_return_t rc;
3437
3438   if (! libmemcached_util_version_check(memc, 1, 4, 4))
3439     return TEST_SKIPPED;
3440
3441   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3442
3443   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3444
3445   /* Turn this into a help function */
3446   {
3447     memcached_result_st results_obj;
3448     memcached_result_st *results;
3449
3450     results= memcached_result_create(memc, &results_obj);
3451
3452     while ((results= memcached_fetch_result(memc, &results_obj, &rc)))
3453     {
3454       test_true(results);
3455       test_true(rc == MEMCACHED_SUCCESS);
3456     }
3457
3458     memcached_result_free(&results_obj);
3459   }
3460
3461   return TEST_SUCCESS;
3462 }
3463
3464 static test_return_t mget_read_function(memcached_st *memc)
3465 {
3466   memcached_return_t rc;
3467   size_t counter;
3468   memcached_execute_fn callbacks[1];
3469
3470   if (! libmemcached_util_version_check(memc, 1, 4, 4))
3471     return TEST_SKIPPED;
3472
3473   rc= memcached_mget(memc, global_keys, global_keys_length, global_count);
3474
3475   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
3476
3477   callbacks[0]= &callback_counter;
3478   counter= 0;
3479   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
3480
3481   return TEST_SUCCESS;
3482 }
3483
3484 static test_return_t delete_generate(memcached_st *memc)
3485 {
3486   for (size_t x= 0; x < global_count; x++)
3487   {
3488     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3489   }
3490
3491   return TEST_SUCCESS;
3492 }
3493
3494 static test_return_t delete_buffer_generate(memcached_st *memc)
3495 {
3496   uint64_t latch= 0;
3497
3498   latch= 1;
3499   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, latch);
3500
3501   for (size_t x= 0; x < global_count; x++)
3502   {
3503     (void)memcached_delete(memc, global_keys[x], global_keys_length[x], (time_t)0);
3504   }
3505
3506   return TEST_SUCCESS;
3507 }
3508
3509 static test_return_t add_host_test1(memcached_st *memc)
3510 {
3511   memcached_return_t rc;
3512   char servername[]= "0.example.com";
3513   memcached_server_st *servers;
3514
3515   servers= memcached_server_list_append_with_weight(NULL, servername, 400, 0, &rc);
3516   test_true(servers);
3517   test_true(1 == memcached_server_list_count(servers));
3518
3519   for (size_t x= 2; x < 20; x++)
3520   {
3521     char buffer[SMALL_STRING_LEN];
3522
3523     snprintf(buffer, SMALL_STRING_LEN, "%lu.example.com", (unsigned long)(400 +x));
3524     servers= memcached_server_list_append_with_weight(servers, buffer, 401, 0,
3525                                      &rc);
3526     test_true(rc == MEMCACHED_SUCCESS);
3527     test_true(x == memcached_server_list_count(servers));
3528   }
3529
3530   rc= memcached_server_push(memc, servers);
3531   test_true(rc == MEMCACHED_SUCCESS);
3532   rc= memcached_server_push(memc, servers);
3533   test_true(rc == MEMCACHED_SUCCESS);
3534
3535   memcached_server_list_free(servers);
3536
3537   return TEST_SUCCESS;
3538 }
3539
3540 static test_return_t pre_nonblock(memcached_st *memc)
3541 {
3542   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3543
3544   return TEST_SUCCESS;
3545 }
3546
3547 static test_return_t pre_cork(memcached_st *memc)
3548 {
3549   memcached_return_t rc;
3550   bool set= true;
3551
3552   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CORK, set);
3553
3554 #ifdef __APPLE__
3555   return TEST_SKIPPED;
3556 #endif
3557
3558   if (rc == MEMCACHED_SUCCESS)
3559     return TEST_SUCCESS;
3560
3561   return TEST_SKIPPED;
3562 }
3563
3564 static test_return_t pre_cork_and_nonblock(memcached_st *memc)
3565 {
3566   test_return_t rc;
3567
3568   rc= pre_cork(memc);
3569
3570 #ifdef __APPLE__
3571   return TEST_SKIPPED;
3572 #endif
3573
3574   if (rc != TEST_SUCCESS)
3575     return rc;
3576
3577   return pre_nonblock(memc);
3578 }
3579
3580 static test_return_t pre_nonblock_binary(memcached_st *memc)
3581 {
3582   memcached_return_t rc= MEMCACHED_FAILURE;
3583   memcached_st *memc_clone;
3584
3585   memc_clone= memcached_clone(NULL, memc);
3586   test_true(memc_clone);
3587   // The memcached_version needs to be done on a clone, because the server
3588   // will not toggle protocol on an connection.
3589   memcached_version(memc_clone);
3590
3591   if (libmemcached_util_version_check(memc_clone, 1, 4, 4))
3592   {
3593     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
3594     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3595     test_true(rc == MEMCACHED_SUCCESS);
3596     test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3597   }
3598   else
3599   {
3600     return TEST_SKIPPED;
3601   }
3602
3603   memcached_free(memc_clone);
3604
3605   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3606 }
3607
3608 static test_return_t pre_murmur(memcached_st *memc)
3609 {
3610 #ifdef HAVE_MURMUR_HASH
3611   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3612   return TEST_SUCCESS;
3613 #else
3614   (void) memc;
3615   return TEST_SKIPPED;
3616 #endif
3617 }
3618
3619 static test_return_t pre_jenkins(memcached_st *memc)
3620 {
3621   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_JENKINS);
3622
3623   return TEST_SUCCESS;
3624 }
3625
3626
3627 static test_return_t pre_md5(memcached_st *memc)
3628 {
3629   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MD5);
3630
3631   return TEST_SUCCESS;
3632 }
3633
3634 static test_return_t pre_crc(memcached_st *memc)
3635 {
3636   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_CRC);
3637
3638   return TEST_SUCCESS;
3639 }
3640
3641 static test_return_t pre_hsieh(memcached_st *memc)
3642 {
3643 #ifdef HAVE_HSIEH_HASH
3644   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_HSIEH);
3645   return TEST_SUCCESS;
3646 #else
3647   (void) memc;
3648   return TEST_SKIPPED;
3649 #endif
3650 }
3651
3652 static test_return_t pre_hash_fnv1_64(memcached_st *memc)
3653 {
3654   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_MURMUR);
3655
3656   return TEST_SUCCESS;
3657 }
3658
3659 static test_return_t pre_hash_fnv1a_64(memcached_st *memc)
3660 {
3661   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_64);
3662
3663   return TEST_SUCCESS;
3664 }
3665
3666 static test_return_t pre_hash_fnv1_32(memcached_st *memc)
3667 {
3668   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1_32);
3669
3670   return TEST_SUCCESS;
3671 }
3672
3673 static test_return_t pre_hash_fnv1a_32(memcached_st *memc)
3674 {
3675   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH, (uint64_t)MEMCACHED_HASH_FNV1A_32);
3676
3677   return TEST_SUCCESS;
3678 }
3679
3680 static test_return_t pre_behavior_ketama(memcached_st *memc)
3681 {
3682   memcached_return_t rc;
3683   uint64_t value;
3684
3685   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA, 1);
3686   test_true(rc == MEMCACHED_SUCCESS);
3687
3688   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA);
3689   test_true(value == 1);
3690
3691   return TEST_SUCCESS;
3692 }
3693
3694 static test_return_t pre_behavior_ketama_weighted(memcached_st *memc)
3695 {
3696   memcached_return_t rc;
3697   uint64_t value;
3698
3699   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
3700   test_true(rc == MEMCACHED_SUCCESS);
3701
3702   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
3703   test_true(value == 1);
3704
3705   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH, MEMCACHED_HASH_MD5);
3706   test_true(rc == MEMCACHED_SUCCESS);
3707
3708   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_HASH);
3709   test_true(value == MEMCACHED_HASH_MD5);
3710
3711   return TEST_SUCCESS;
3712 }
3713
3714 /**
3715   @note This should be testing to see if the server really supports the binary protocol.
3716 */
3717 static test_return_t pre_binary(memcached_st *memc)
3718 {
3719   memcached_return_t rc= MEMCACHED_FAILURE;
3720
3721   if (libmemcached_util_version_check(memc, 1, 4, 4))
3722   {
3723     rc = memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3724     test_true(rc == MEMCACHED_SUCCESS);
3725     test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL) == 1);
3726   }
3727
3728   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3729 }
3730
3731 static test_return_t pre_sasl(memcached_st *memc)
3732 {
3733   memcached_return_t rc= MEMCACHED_FAILURE;
3734
3735 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
3736   const char *server= getenv("LIBMEMCACHED_TEST_SASL_SERVER");
3737   const char *user= getenv("LIBMEMCACHED_TEST_SASL_USERNAME");
3738   const char *pass= getenv("LIBMEMCACHED_TEST_SASL_PASSWORD");
3739
3740   if (server != NULL && user != NULL && pass != NULL)
3741   {
3742     memcached_server_st *servers= memcached_servers_parse(server);
3743     test_true(servers != NULL);
3744     memcached_servers_reset(memc);
3745     test_true(memcached_server_push(memc, servers) == MEMCACHED_SUCCESS);
3746     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
3747     rc= memcached_set_sasl_auth_data(memc, user, pass);
3748     test_true(rc == MEMCACHED_SUCCESS);
3749   }
3750 #else
3751   (void)memc;
3752 #endif
3753
3754   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3755 }
3756
3757 static test_return_t pre_replication(memcached_st *memc)
3758 {
3759   test_return_t test_rc;
3760   test_rc= pre_binary(memc);
3761
3762   if (test_rc != TEST_SUCCESS)
3763     return test_rc;
3764
3765   /*
3766    * Make sure that we store the item on all servers
3767    * (master + replicas == number of servers)
3768    */
3769   memcached_return_t rc;
3770   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS,
3771                              memcached_server_count(memc) - 1);
3772   test_true(rc == MEMCACHED_SUCCESS);
3773   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS) == memcached_server_count(memc) - 1);
3774
3775   return rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_SKIPPED;
3776 }
3777
3778
3779 static test_return_t pre_replication_noblock(memcached_st *memc)
3780 {
3781   test_return_t rc;
3782
3783   rc= pre_replication(memc);
3784   if (rc != TEST_SUCCESS)
3785     return rc;
3786
3787   rc= pre_nonblock(memc);
3788
3789   return rc;
3790 }
3791
3792
3793 static void my_free(const memcached_st *ptr, void *mem, void *context)
3794 {
3795   (void)context;
3796   (void)ptr;
3797 #ifdef HARD_MALLOC_TESTS
3798   void *real_ptr= (mem == NULL) ? mem : (void*)((caddr_t)mem - 8);
3799   free(real_ptr);
3800 #else
3801   free(mem);
3802 #endif
3803 }
3804
3805
3806 static void *my_malloc(const memcached_st *ptr, const size_t size, void *context)
3807 {
3808   (void)context;
3809   (void)ptr;
3810 #ifdef HARD_MALLOC_TESTS
3811   void *ret= malloc(size + 8);
3812   if (ret != NULL)
3813   {
3814     ret= (void*)((caddr_t)ret + 8);
3815   }
3816 #else
3817   void *ret= malloc(size);
3818 #endif
3819
3820   if (ret != NULL)
3821   {
3822     memset(ret, 0xff, size);
3823   }
3824
3825   return ret;
3826 }
3827
3828
3829 static void *my_realloc(const memcached_st *ptr, void *mem, const size_t size, void *context)
3830 {
3831   (void)context;
3832 #ifdef HARD_MALLOC_TESTS
3833   void *real_ptr= (mem == NULL) ? NULL : (void*)((caddr_t)mem - 8);
3834   void *nmem= realloc(real_ptr, size + 8);
3835
3836   void *ret= NULL;
3837   if (nmem != NULL)
3838   {
3839     ret= (void*)((caddr_t)nmem + 8);
3840   }
3841
3842   return ret;
3843 #else
3844   (void)ptr;
3845   return realloc(mem, size);
3846 #endif
3847 }
3848
3849
3850 static void *my_calloc(const memcached_st *ptr, size_t nelem, const size_t size, void *context)
3851 {
3852   (void)context;
3853 #ifdef HARD_MALLOC_TESTS
3854   void *mem= my_malloc(ptr, nelem * size);
3855   if (mem)
3856   {
3857     memset(mem, 0, nelem * size);
3858   }
3859
3860   return mem;
3861 #else
3862   (void)ptr;
3863   return calloc(nelem, size);
3864 #endif
3865 }
3866
3867 static test_return_t set_prefix(memcached_st *memc)
3868 {
3869   memcached_return_t rc;
3870   const char *key= "mine";
3871   char *value;
3872
3873   /* Make sure be default none exists */
3874   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3875   test_true(rc == MEMCACHED_FAILURE);
3876
3877   /* Test a clean set */
3878   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3879   test_true_got(rc == MEMCACHED_SUCCESS, memcached_last_error_message(memc));
3880
3881   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3882   test_true(value);
3883   test_true(memcmp(value, key, 4) == 0);
3884   test_true(rc == MEMCACHED_SUCCESS);
3885
3886   /* Test that we can turn it off */
3887   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3888   test_true(rc == MEMCACHED_SUCCESS);
3889
3890   value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3891   test_false(value);
3892   test_true(rc == MEMCACHED_FAILURE);
3893
3894   /* Now setup for main test */
3895   rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, (void *)key);
3896   test_true(rc == MEMCACHED_SUCCESS);
3897
3898   value= (char *)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3899   test_true(value);
3900   test_true(rc == MEMCACHED_SUCCESS);
3901   test_true(memcmp(value, key, 4) == 0);
3902
3903   /* Set to Zero, and then Set to something too large */
3904   {
3905     char long_key[255];
3906     memset(long_key, 0, 255);
3907
3908     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, NULL);
3909     test_true(rc == MEMCACHED_SUCCESS);
3910
3911     value= (char*)memcached_callback_get(memc, MEMCACHED_CALLBACK_PREFIX_KEY, &rc);
3912     test_false(value);
3913     test_true(rc == MEMCACHED_FAILURE);
3914     test_true(value == NULL);
3915
3916     /* Test a long key for failure */
3917     /* TODO, extend test to determine based on setting, what result should be */
3918     strncpy(long_key, "Thisismorethentheallottednumberofcharacters", sizeof(long_key));
3919     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3920     //test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3921     test_true(rc == MEMCACHED_SUCCESS);
3922
3923     /* Now test a key with spaces (which will fail from long key, since bad key is not set) */
3924     strncpy(long_key, "This is more then the allotted number of characters", sizeof(long_key));
3925     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3926     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3927
3928     /* Test for a bad prefix, but with a short key */
3929     rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_VERIFY_KEY, 1);
3930     test_true(rc == MEMCACHED_SUCCESS);
3931
3932     strncpy(long_key, "dog cat", sizeof(long_key));
3933     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_PREFIX_KEY, long_key);
3934     test_true(rc == MEMCACHED_BAD_KEY_PROVIDED);
3935   }
3936
3937   return TEST_SUCCESS;
3938 }
3939
3940
3941 #ifdef MEMCACHED_ENABLE_DEPRECATED
3942 static test_return_t deprecated_set_memory_alloc(memcached_st *memc)
3943 {
3944   void *test_ptr= NULL;
3945   void *cb_ptr= NULL;
3946   {
3947     memcached_malloc_fn malloc_cb=
3948       (memcached_malloc_fn)my_malloc;
3949     cb_ptr= *(void **)&malloc_cb;
3950     memcached_return_t rc;
3951
3952     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, cb_ptr);
3953     test_true(rc == MEMCACHED_SUCCESS);
3954     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_MALLOC_FUNCTION, &rc);
3955     test_true(rc == MEMCACHED_SUCCESS);
3956     test_true(test_ptr == cb_ptr);
3957   }
3958
3959   {
3960     memcached_realloc_fn realloc_cb=
3961       (memcached_realloc_fn)my_realloc;
3962     cb_ptr= *(void **)&realloc_cb;
3963     memcached_return_t rc;
3964
3965     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, cb_ptr);
3966     test_true(rc == MEMCACHED_SUCCESS);
3967     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_REALLOC_FUNCTION, &rc);
3968     test_true(rc == MEMCACHED_SUCCESS);
3969     test_true(test_ptr == cb_ptr);
3970   }
3971
3972   {
3973     memcached_free_fn free_cb=
3974       (memcached_free_fn)my_free;
3975     cb_ptr= *(void **)&free_cb;
3976     memcached_return_t rc;
3977
3978     rc= memcached_callback_set(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, cb_ptr);
3979     test_true(rc == MEMCACHED_SUCCESS);
3980     test_ptr= memcached_callback_get(memc, MEMCACHED_CALLBACK_FREE_FUNCTION, &rc);
3981     test_true(rc == MEMCACHED_SUCCESS);
3982     test_true(test_ptr == cb_ptr);
3983   }
3984
3985   return TEST_SUCCESS;
3986 }
3987 #endif
3988
3989
3990 static test_return_t set_memory_alloc(memcached_st *memc)
3991 {
3992   memcached_return_t rc;
3993   rc= memcached_set_memory_allocators(memc, NULL, my_free,
3994                                       my_realloc, my_calloc, NULL);
3995   test_true(rc == MEMCACHED_FAILURE);
3996
3997   rc= memcached_set_memory_allocators(memc, my_malloc, my_free,
3998                                       my_realloc, my_calloc, NULL);
3999
4000   memcached_malloc_fn mem_malloc;
4001   memcached_free_fn mem_free;
4002   memcached_realloc_fn mem_realloc;
4003   memcached_calloc_fn mem_calloc;
4004   memcached_get_memory_allocators(memc, &mem_malloc, &mem_free,
4005                                   &mem_realloc, &mem_calloc);
4006
4007   test_true(mem_malloc == my_malloc);
4008   test_true(mem_realloc == my_realloc);
4009   test_true(mem_calloc == my_calloc);
4010   test_true(mem_free == my_free);
4011
4012   return TEST_SUCCESS;
4013 }
4014
4015 static test_return_t enable_consistent_crc(memcached_st *memc)
4016 {
4017   test_return_t rc;
4018   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
4019   memcached_hash_t hash;
4020   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
4021   if ((rc= pre_crc(memc)) != TEST_SUCCESS)
4022     return rc;
4023
4024   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
4025   test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
4026
4027   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
4028
4029   if (hash != MEMCACHED_HASH_CRC)
4030     return TEST_SKIPPED;
4031
4032   return TEST_SUCCESS;
4033 }
4034
4035 static test_return_t enable_consistent_hsieh(memcached_st *memc)
4036 {
4037   test_return_t rc;
4038   memcached_server_distribution_t value= MEMCACHED_DISTRIBUTION_CONSISTENT;
4039   memcached_hash_t hash;
4040   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION, value);
4041   if ((rc= pre_hsieh(memc)) != TEST_SUCCESS)
4042     return rc;
4043
4044   value= (memcached_server_distribution_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_DISTRIBUTION);
4045   test_true(value == MEMCACHED_DISTRIBUTION_CONSISTENT);
4046
4047   hash= (memcached_hash_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_HASH);
4048
4049   if (hash != MEMCACHED_HASH_HSIEH)
4050     return TEST_SKIPPED;
4051
4052
4053   return TEST_SUCCESS;
4054 }
4055
4056 static test_return_t enable_cas(memcached_st *memc)
4057 {
4058   unsigned int set= 1;
4059
4060   if (libmemcached_util_version_check(memc, 1, 2, 4))
4061   {
4062     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, set);
4063
4064     return TEST_SUCCESS;
4065   }
4066
4067   return TEST_SKIPPED;
4068 }
4069
4070 static test_return_t check_for_1_2_3(memcached_st *memc)
4071 {
4072   memcached_version(memc);
4073
4074   memcached_server_instance_st instance=
4075     memcached_server_instance_by_position(memc, 0);
4076
4077   if ((instance->major_version >= 1 && (instance->minor_version == 2 && instance->micro_version >= 4))
4078       || instance->minor_version > 2)
4079   {
4080     return TEST_SUCCESS;
4081   }
4082
4083   return TEST_SKIPPED;
4084 }
4085
4086 static test_return_t pre_unix_socket(memcached_st *memc)
4087 {
4088   memcached_return_t rc;
4089   struct stat buf;
4090
4091   memcached_servers_reset(memc);
4092
4093   if (stat("/tmp/memcached.socket", &buf))
4094     return TEST_SKIPPED;
4095
4096   rc= memcached_server_add_unix_socket_with_weight(memc, "/tmp/memcached.socket", 0);
4097
4098   return ( rc == MEMCACHED_SUCCESS ? TEST_SUCCESS : TEST_FAILURE );
4099 }
4100
4101 static test_return_t pre_nodelay(memcached_st *memc)
4102 {
4103   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 0);
4104   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 0);
4105
4106   return TEST_SUCCESS;
4107 }
4108
4109 static test_return_t pre_settimer(memcached_st *memc)
4110 {
4111   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
4112   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
4113
4114   return TEST_SUCCESS;
4115 }
4116
4117 static test_return_t poll_timeout(memcached_st *memc)
4118 {
4119   size_t timeout;
4120
4121   timeout= 100;
4122
4123   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, timeout);
4124
4125   timeout= (size_t)memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT);
4126
4127   test_true(timeout == 100);
4128
4129   return TEST_SUCCESS;
4130 }
4131
4132 static test_return_t noreply_test(memcached_st *memc)
4133 {
4134   memcached_return_t ret;
4135   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
4136   test_true(ret == MEMCACHED_SUCCESS);
4137   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
4138   test_true(ret == MEMCACHED_SUCCESS);
4139   ret= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS, 1);
4140   test_true(ret == MEMCACHED_SUCCESS);
4141   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_NOREPLY) == 1);
4142   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS) == 1);
4143   test_true(memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_SUPPORT_CAS) == 1);
4144
4145   for (int count=0; count < 5; ++count)
4146   {
4147     for (size_t x= 0; x < 100; ++x)
4148     {
4149       char key[10];
4150       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4151       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4152
4153       size_t len= (size_t)check_length;
4154
4155       switch (count)
4156       {
4157       case 0:
4158         ret= memcached_add(memc, key, len, key, len, 0, 0);
4159         break;
4160       case 1:
4161         ret= memcached_replace(memc, key, len, key, len, 0, 0);
4162         break;
4163       case 2:
4164         ret= memcached_set(memc, key, len, key, len, 0, 0);
4165         break;
4166       case 3:
4167         ret= memcached_append(memc, key, len, key, len, 0, 0);
4168         break;
4169       case 4:
4170         ret= memcached_prepend(memc, key, len, key, len, 0, 0);
4171         break;
4172       default:
4173         test_true(count);
4174         break;
4175       }
4176       test_true(ret == MEMCACHED_SUCCESS || ret == MEMCACHED_BUFFERED);
4177     }
4178
4179     /*
4180     ** NOTE: Don't ever do this in your code! this is not a supported use of the
4181     ** API and is _ONLY_ done this way to verify that the library works the
4182     ** way it is supposed to do!!!!
4183     */
4184     int no_msg=0;
4185     for (uint32_t x= 0; x < memcached_server_count(memc); ++x)
4186     {
4187       memcached_server_instance_st instance=
4188         memcached_server_instance_by_position(memc, x);
4189       no_msg+=(int)(instance->cursor_active);
4190     }
4191
4192     test_true(no_msg == 0);
4193     test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4194
4195     /*
4196      ** Now validate that all items was set properly!
4197      */
4198     for (size_t x= 0; x < 100; ++x)
4199     {
4200       char key[10];
4201
4202       int check_length= (size_t)snprintf(key, sizeof(key), "%lu", (unsigned long)x);
4203
4204       test_false((size_t)check_length >= sizeof(key) || check_length < 0);
4205
4206       size_t len= (size_t)check_length;
4207       size_t length;
4208       uint32_t flags;
4209       char* value=memcached_get(memc, key, strlen(key),
4210                                 &length, &flags, &ret);
4211       test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4212       switch (count)
4213       {
4214       case 0: /* FALLTHROUGH */
4215       case 1: /* FALLTHROUGH */
4216       case 2:
4217         test_true(strncmp(value, key, len) == 0);
4218         test_true(len == length);
4219         break;
4220       case 3:
4221         test_true(length == len * 2);
4222         break;
4223       case 4:
4224         test_true(length == len * 3);
4225         break;
4226       default:
4227         test_true(count);
4228         break;
4229       }
4230       free(value);
4231     }
4232   }
4233
4234   /* Try setting an illegal cas value (should not return an error to
4235    * the caller (because we don't expect a return message from the server)
4236    */
4237   const char* keys[]= {"0"};
4238   size_t lengths[]= {1};
4239   size_t length;
4240   uint32_t flags;
4241   memcached_result_st results_obj;
4242   memcached_result_st *results;
4243   ret= memcached_mget(memc, keys, lengths, 1);
4244   test_true(ret == MEMCACHED_SUCCESS);
4245
4246   results= memcached_result_create(memc, &results_obj);
4247   test_true(results);
4248   results= memcached_fetch_result(memc, &results_obj, &ret);
4249   test_true(results);
4250   test_true(ret == MEMCACHED_SUCCESS);
4251   uint64_t cas= memcached_result_cas(results);
4252   memcached_result_free(&results_obj);
4253
4254   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4255   test_true(ret == MEMCACHED_SUCCESS);
4256
4257   /*
4258    * The item will have a new cas value, so try to set it again with the old
4259    * value. This should fail!
4260    */
4261   ret= memcached_cas(memc, keys[0], lengths[0], keys[0], lengths[0], 0, 0, cas);
4262   test_true(ret == MEMCACHED_SUCCESS);
4263   test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
4264   char* value=memcached_get(memc, keys[0], lengths[0], &length, &flags, &ret);
4265   test_true(ret == MEMCACHED_SUCCESS && value != NULL);
4266   free(value);
4267
4268   return TEST_SUCCESS;
4269 }
4270
4271 static test_return_t analyzer_test(memcached_st *memc)
4272 {
4273   memcached_return_t rc;
4274   memcached_stat_st *memc_stat;
4275   memcached_analysis_st *report;
4276
4277   memc_stat= memcached_stat(memc, NULL, &rc);
4278   test_true(rc == MEMCACHED_SUCCESS);
4279   test_true(memc_stat);
4280
4281   report= memcached_analyze(memc, memc_stat, &rc);
4282   test_true(rc == MEMCACHED_SUCCESS);
4283   test_true(report);
4284
4285   free(report);
4286   memcached_stat_free(NULL, memc_stat);
4287
4288   return TEST_SUCCESS;
4289 }
4290
4291 /* Count the objects */
4292 static memcached_return_t callback_dump_counter(const memcached_st *ptr,
4293                                                 const char *key,
4294                                                 size_t key_length,
4295                                                 void *context)
4296 {
4297   (void)ptr; (void)key; (void)key_length;
4298   size_t *counter= (size_t *)context;
4299
4300   *counter= *counter + 1;
4301
4302   return MEMCACHED_SUCCESS;
4303 }
4304
4305 static test_return_t dump_test(memcached_st *memc)
4306 {
4307   memcached_return_t rc;
4308   size_t counter= 0;
4309   memcached_dump_fn callbacks[1];
4310   test_return_t main_rc;
4311
4312   callbacks[0]= &callback_dump_counter;
4313
4314   /* No support for Binary protocol yet */
4315   if (memc->flags.binary_protocol)
4316     return TEST_SUCCESS;
4317
4318   main_rc= set_test3(memc);
4319
4320   test_true (main_rc == TEST_SUCCESS);
4321
4322   rc= memcached_dump(memc, callbacks, (void *)&counter, 1);
4323   test_true(rc == MEMCACHED_SUCCESS);
4324
4325   /* We may have more then 32 if our previous flush has not completed */
4326   test_true(counter >= 32);
4327
4328   return TEST_SUCCESS;
4329 }
4330
4331 #ifdef HAVE_LIBMEMCACHEDUTIL
4332
4333 struct test_pool_context_st {
4334   memcached_pool_st* pool;
4335   memcached_st* mmc;
4336 };
4337
4338 static void* connection_release(void *arg)
4339 {
4340   test_pool_context_st *resource= static_cast<test_pool_context_st *>(arg);
4341
4342   usleep(250);
4343   // Release all of the memc we are holding
4344   assert(memcached_pool_push(resource->pool, resource->mmc) == MEMCACHED_SUCCESS);
4345   return arg;
4346 }
4347
4348 #define POOL_SIZE 10
4349 static test_return_t connection_pool_test(memcached_st *memc)
4350 {
4351   memcached_pool_st* pool= memcached_pool_create(memc, 5, POOL_SIZE);
4352   test_true(pool != NULL);
4353   memcached_st *mmc[POOL_SIZE];
4354   memcached_return_t rc;
4355
4356   // Fill up our array that we will store the memc that are in the pool
4357   for (size_t x= 0; x < POOL_SIZE; ++x)
4358   {
4359     mmc[x]= memcached_pool_pop(pool, false, &rc);
4360     test_true(mmc[x] != NULL);
4361     test_true(rc == MEMCACHED_SUCCESS);
4362   }
4363
4364   // All memc should be gone
4365   test_true(memcached_pool_pop(pool, false, &rc) == NULL);
4366   test_true(rc == MEMCACHED_SUCCESS);
4367
4368   pthread_t tid;
4369   test_pool_context_st item= { pool, mmc[9] };
4370
4371   pthread_create(&tid, NULL, connection_release, &item);
4372   mmc[9]= memcached_pool_pop(pool, true, &rc);
4373   test_true(rc == MEMCACHED_SUCCESS);
4374   pthread_join(tid, NULL);
4375   test_true(mmc[9]);
4376   const char *key= "key";
4377   size_t keylen= strlen(key);
4378
4379   // verify that I can do ops with all connections
4380   rc= memcached_set(mmc[0], key, keylen, "0", 1, 0, 0);
4381   test_true(rc == MEMCACHED_SUCCESS);
4382
4383   for (size_t x= 0; x < POOL_SIZE; ++x)
4384   {
4385     uint64_t number_value;
4386     rc= memcached_increment(mmc[x], key, keylen, 1, &number_value);
4387     test_true(rc == MEMCACHED_SUCCESS);
4388     test_true(number_value == (x+1));
4389   }
4390
4391   // Release them..
4392   for (size_t x= 0; x < POOL_SIZE; ++x)
4393   {
4394     test_true(memcached_pool_push(pool, mmc[x]) == MEMCACHED_SUCCESS);
4395   }
4396
4397
4398   /* verify that I can set behaviors on the pool when I don't have all
4399    * of the connections in the pool. It should however be enabled
4400    * when I push the item into the pool
4401    */
4402   mmc[0]= memcached_pool_pop(pool, false, &rc);
4403   test_true(mmc[0] != NULL);
4404
4405   rc= memcached_pool_behavior_set(pool, MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK, 9999);
4406   test_true(rc == MEMCACHED_SUCCESS);
4407
4408   mmc[1]= memcached_pool_pop(pool, false, &rc);
4409   test_true(mmc[1] != NULL);
4410
4411   test_true(memcached_behavior_get(mmc[1], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4412   test_true(memcached_pool_push(pool, mmc[1]) == MEMCACHED_SUCCESS);
4413   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4414
4415   mmc[0]= memcached_pool_pop(pool, false, &rc);
4416   test_true(memcached_behavior_get(mmc[0], MEMCACHED_BEHAVIOR_IO_MSG_WATERMARK) == 9999);
4417   test_true(memcached_pool_push(pool, mmc[0]) == MEMCACHED_SUCCESS);
4418
4419   test_true(memcached_pool_destroy(pool) == memc);
4420
4421   return TEST_SUCCESS;
4422 }
4423
4424 static test_return_t util_version_test(memcached_st *memc)
4425 {
4426   bool if_successful;
4427
4428   if_successful= libmemcached_util_version_check(memc, 0, 0, 0);
4429   test_true(if_successful == true);
4430
4431   if_successful= libmemcached_util_version_check(memc, 9, 9, 9);
4432
4433   // We expect failure
4434   if (if_successful)
4435   {
4436     fprintf(stderr, "\n----------------------------------------------------------------------\n");
4437     fprintf(stderr, "\nDumping Server Information\n\n");
4438     memcached_server_fn callbacks[1];
4439
4440     callbacks[0]= dump_server_information;
4441     memcached_server_cursor(memc, callbacks, (void *)stderr,  1);
4442     fprintf(stderr, "\n----------------------------------------------------------------------\n");
4443   }
4444   test_true(if_successful == false);
4445
4446   memcached_server_instance_st instance=
4447     memcached_server_instance_by_position(memc, 0);
4448
4449   memcached_version(memc);
4450
4451   // We only use one binary when we test, so this should be just fine.
4452   if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, instance->micro_version);
4453   test_true(if_successful == true);
4454
4455   if (instance->micro_version > 0)
4456     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version -1));
4457   else if (instance->minor_version > 0)
4458     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version - 1), instance->micro_version);
4459   else if (instance->major_version > 0)
4460     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version -1), instance->minor_version, instance->micro_version);
4461
4462   test_true(if_successful == true);
4463
4464   if (instance->micro_version > 0)
4465     if_successful= libmemcached_util_version_check(memc, instance->major_version, instance->minor_version, (uint8_t)(instance->micro_version +1));
4466   else if (instance->minor_version > 0)
4467     if_successful= libmemcached_util_version_check(memc, instance->major_version, (uint8_t)(instance->minor_version +1), instance->micro_version);
4468   else if (instance->major_version > 0)
4469     if_successful= libmemcached_util_version_check(memc, (uint8_t)(instance->major_version +1), instance->minor_version, instance->micro_version);
4470
4471   test_true(if_successful == false);
4472
4473   return TEST_SUCCESS;
4474 }
4475
4476 static test_return_t ping_test(memcached_st *memc)
4477 {
4478   memcached_return_t rc;
4479   memcached_server_instance_st instance=
4480     memcached_server_instance_by_position(memc, 0);
4481
4482   // Test both the version that returns a code, and the one that does not.
4483   test_true(libmemcached_util_ping(memcached_server_name(instance),
4484                                    memcached_server_port(instance), NULL));
4485
4486   test_true(libmemcached_util_ping(memcached_server_name(instance),
4487                                    memcached_server_port(instance), &rc));
4488
4489   test_true(rc == MEMCACHED_SUCCESS);
4490
4491   return TEST_SUCCESS;
4492 }
4493 #endif
4494
4495
4496 #if 0
4497 static test_return_t hash_sanity_test (memcached_st *memc)
4498 {
4499   (void)memc;
4500
4501   assert(MEMCACHED_HASH_DEFAULT == MEMCACHED_HASH_DEFAULT);
4502   assert(MEMCACHED_HASH_MD5 == MEMCACHED_HASH_MD5);
4503   assert(MEMCACHED_HASH_CRC == MEMCACHED_HASH_CRC);
4504   assert(MEMCACHED_HASH_FNV1_64 == MEMCACHED_HASH_FNV1_64);
4505   assert(MEMCACHED_HASH_FNV1A_64 == MEMCACHED_HASH_FNV1A_64);
4506   assert(MEMCACHED_HASH_FNV1_32 == MEMCACHED_HASH_FNV1_32);
4507   assert(MEMCACHED_HASH_FNV1A_32 == MEMCACHED_HASH_FNV1A_32);
4508 #ifdef HAVE_HSIEH_HASH
4509   assert(MEMCACHED_HASH_HSIEH == MEMCACHED_HASH_HSIEH);
4510 #endif
4511   assert(MEMCACHED_HASH_MURMUR == MEMCACHED_HASH_MURMUR);
4512   assert(MEMCACHED_HASH_JENKINS == MEMCACHED_HASH_JENKINS);
4513   assert(MEMCACHED_HASH_MAX == MEMCACHED_HASH_MAX);
4514
4515   return TEST_SUCCESS;
4516 }
4517 #endif
4518
4519 static test_return_t hsieh_avaibility_test (memcached_st *memc)
4520 {
4521   memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
4522 #ifdef HAVE_HSIEH_HASH
4523   expected_rc= MEMCACHED_SUCCESS;
4524 #endif
4525   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4526                                                 (uint64_t)MEMCACHED_HASH_HSIEH);
4527   test_true(rc == expected_rc);
4528
4529   return TEST_SUCCESS;
4530 }
4531
4532 static test_return_t murmur_avaibility_test (memcached_st *memc)
4533 {
4534   memcached_return_t expected_rc= MEMCACHED_INVALID_ARGUMENTS;
4535 #ifdef HAVE_MURMUR_HASH
4536   expected_rc= MEMCACHED_SUCCESS;
4537 #endif
4538   memcached_return_t rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_HASH,
4539                                                 (uint64_t)MEMCACHED_HASH_MURMUR);
4540   test_true(rc == expected_rc);
4541
4542   return TEST_SUCCESS;
4543 }
4544
4545 static test_return_t one_at_a_time_run (memcached_st *memc)
4546 {
4547   uint32_t x;
4548   const char **ptr;
4549   (void)memc;
4550
4551   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4552   {
4553     uint32_t hash_val;
4554
4555     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_DEFAULT);
4556     test_true(one_at_a_time_values[x] == hash_val);
4557   }
4558
4559   return TEST_SUCCESS;
4560 }
4561
4562 static test_return_t md5_run (memcached_st *memc)
4563 {
4564   uint32_t x;
4565   const char **ptr;
4566   (void)memc;
4567
4568   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4569   {
4570     uint32_t hash_val;
4571
4572     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MD5);
4573     test_true(md5_values[x] == hash_val);
4574   }
4575
4576   return TEST_SUCCESS;
4577 }
4578
4579 static test_return_t crc_run (memcached_st *memc)
4580 {
4581   uint32_t x;
4582   const char **ptr;
4583   (void)memc;
4584
4585   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4586   {
4587     uint32_t hash_val;
4588
4589     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_CRC);
4590     test_true(crc_values[x] == hash_val);
4591   }
4592
4593   return TEST_SUCCESS;
4594 }
4595
4596 static test_return_t fnv1_64_run (memcached_st *memc)
4597 {
4598   uint32_t x;
4599   const char **ptr;
4600   (void)memc;
4601
4602   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4603   {
4604     uint32_t hash_val;
4605
4606     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_64);
4607     test_true(fnv1_64_values[x] == hash_val);
4608   }
4609
4610   return TEST_SUCCESS;
4611 }
4612
4613 static test_return_t fnv1a_64_run (memcached_st *memc)
4614 {
4615   uint32_t x;
4616   const char **ptr;
4617   (void)memc;
4618
4619   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4620   {
4621     uint32_t hash_val;
4622
4623     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_64);
4624     test_true(fnv1a_64_values[x] == hash_val);
4625   }
4626
4627   return TEST_SUCCESS;
4628 }
4629
4630 static test_return_t fnv1_32_run (memcached_st *memc)
4631 {
4632   uint32_t x;
4633   const char **ptr;
4634   (void)memc;
4635
4636   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4637   {
4638     uint32_t hash_val;
4639
4640     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1_32);
4641     test_true(fnv1_32_values[x] == hash_val);
4642   }
4643
4644   return TEST_SUCCESS;
4645 }
4646
4647 static test_return_t fnv1a_32_run (memcached_st *memc)
4648 {
4649   uint32_t x;
4650   const char **ptr;
4651   (void)memc;
4652
4653   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4654   {
4655     uint32_t hash_val;
4656
4657     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_FNV1A_32);
4658     test_true(fnv1a_32_values[x] == hash_val);
4659   }
4660
4661   return TEST_SUCCESS;
4662 }
4663
4664 static test_return_t hsieh_run (memcached_st *memc)
4665 {
4666   uint32_t x;
4667   const char **ptr;
4668   (void)memc;
4669
4670   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4671   {
4672     uint32_t hash_val;
4673
4674     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_HSIEH);
4675     test_true(hsieh_values[x] == hash_val);
4676   }
4677
4678   return TEST_SUCCESS;
4679 }
4680
4681 static test_return_t murmur_run (memcached_st *memc)
4682 {
4683 #ifdef WORDS_BIGENDIAN
4684   (void)murmur_values;
4685   return TEST_SKIPPED;
4686 #else
4687   uint32_t x;
4688   const char **ptr;
4689   (void)memc;
4690
4691   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4692   {
4693     uint32_t hash_val;
4694
4695     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_MURMUR);
4696     test_true(murmur_values[x] == hash_val);
4697   }
4698
4699   return TEST_SUCCESS;
4700 #endif
4701 }
4702
4703 static test_return_t jenkins_run (memcached_st *memc)
4704 {
4705   uint32_t x;
4706   const char **ptr;
4707   (void)memc;
4708
4709   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4710   {
4711     uint32_t hash_val;
4712
4713     hash_val= memcached_generate_hash_value(*ptr, strlen(*ptr), MEMCACHED_HASH_JENKINS);
4714     test_true(jenkins_values[x] == hash_val);
4715   }
4716
4717   return TEST_SUCCESS;
4718 }
4719
4720 static uint32_t hash_md5_test_function(const char *string, size_t string_length, void *context)
4721 {
4722   (void)context;
4723   return libhashkit_md5(string, string_length);
4724 }
4725
4726 static uint32_t hash_crc_test_function(const char *string, size_t string_length, void *context)
4727 {
4728   (void)context;
4729   return libhashkit_crc32(string, string_length);
4730 }
4731
4732 static test_return_t memcached_get_hashkit_test (memcached_st *memc)
4733 {
4734   uint32_t x;
4735   const char **ptr;
4736   const hashkit_st *kit;
4737   hashkit_st new_kit;
4738   hashkit_return_t hash_rc;
4739
4740   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};
4741   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};
4742
4743   kit= memcached_get_hashkit(memc);
4744
4745   hashkit_clone(&new_kit, kit);
4746   hash_rc= hashkit_set_custom_function(&new_kit, hash_md5_test_function, NULL);
4747   test_true(hash_rc == HASHKIT_SUCCESS);
4748
4749   memcached_set_hashkit(memc, &new_kit);
4750
4751   /*
4752     Verify Setting the hash.
4753   */
4754   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4755   {
4756     uint32_t hash_val;
4757
4758     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
4759     test_true(md5_values[x] == hash_val);
4760   }
4761
4762
4763   /*
4764     Now check memcached_st.
4765   */
4766   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4767   {
4768     uint32_t hash_val;
4769
4770     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
4771     test_true(md5_hosts[x] == hash_val);
4772   }
4773
4774   hash_rc= hashkit_set_custom_function(&new_kit, hash_crc_test_function, NULL);
4775   test_true(hash_rc == HASHKIT_SUCCESS);
4776
4777   memcached_set_hashkit(memc, &new_kit);
4778
4779   /*
4780     Verify Setting the hash.
4781   */
4782   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4783   {
4784     uint32_t hash_val;
4785
4786     hash_val= hashkit_digest(kit, *ptr, strlen(*ptr));
4787     test_true(crc_values[x] == hash_val);
4788   }
4789
4790   for (ptr= list_to_hash, x= 0; *ptr; ptr++, x++)
4791   {
4792     uint32_t hash_val;
4793
4794     hash_val= memcached_generate_hash(memc, *ptr, strlen(*ptr));
4795     test_true(crc_hosts[x] == hash_val);
4796   }
4797
4798   return TEST_SUCCESS;
4799 }
4800
4801 /*
4802   Test case adapted from John Gorman <johngorman2@gmail.com>
4803
4804   We are testing the error condition when we connect to a server via memcached_get()
4805   but find that the server is not available.
4806 */
4807 static test_return_t memcached_get_MEMCACHED_ERRNO(memcached_st *memc)
4808 {
4809   (void)memc;
4810   memcached_st *tl_memc_h;
4811   memcached_server_st *servers;
4812
4813   const char *key= "MemcachedLives";
4814   size_t len;
4815   uint32_t flags;
4816   memcached_return rc;
4817   char *value;
4818
4819   // Create a handle.
4820   tl_memc_h= memcached_create(NULL);
4821   servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4822   memcached_server_push(tl_memc_h, servers);
4823   memcached_server_list_free(servers);
4824
4825   // See if memcached is reachable.
4826   value= memcached_get(tl_memc_h, key, strlen(key), &len, &flags, &rc);
4827
4828   test_false(value);
4829   test_true(len == 0);
4830   test_false(rc == MEMCACHED_SUCCESS);
4831
4832   memcached_free(tl_memc_h);
4833
4834   return TEST_SUCCESS;
4835 }
4836
4837 /*
4838   We connect to a server which exists, but search for a key that does not exist.
4839 */
4840 static test_return_t memcached_get_MEMCACHED_NOTFOUND(memcached_st *memc)
4841 {
4842   const char *key= "MemcachedKeyNotEXIST";
4843   size_t len;
4844   uint32_t flags;
4845   memcached_return rc;
4846   char *value;
4847
4848   // See if memcached is reachable.
4849   value= memcached_get(memc, key, strlen(key), &len, &flags, &rc);
4850
4851   test_false(value);
4852   test_true(len == 0);
4853   test_true(rc == MEMCACHED_NOTFOUND);
4854
4855   return TEST_SUCCESS;
4856 }
4857
4858 /*
4859   Test case adapted from John Gorman <johngorman2@gmail.com>
4860
4861   We are testing the error condition when we connect to a server via memcached_get_by_key()
4862   but find that the server is not available.
4863 */
4864 static test_return_t memcached_get_by_key_MEMCACHED_ERRNO(memcached_st *memc)
4865 {
4866   (void)memc;
4867   memcached_st *tl_memc_h;
4868   memcached_server_st *servers;
4869
4870   const char *key= "MemcachedLives";
4871   size_t len;
4872   uint32_t flags;
4873   memcached_return rc;
4874   char *value;
4875
4876   // Create a handle.
4877   tl_memc_h= memcached_create(NULL);
4878   servers= memcached_servers_parse("localhost:9898,localhost:9899"); // This server should not exist
4879   memcached_server_push(tl_memc_h, servers);
4880   memcached_server_list_free(servers);
4881
4882   // See if memcached is reachable.
4883   value= memcached_get_by_key(tl_memc_h, key, strlen(key), key, strlen(key), &len, &flags, &rc);
4884
4885   test_false(value);
4886   test_true(len == 0);
4887   test_false(rc == MEMCACHED_SUCCESS);
4888
4889   memcached_free(tl_memc_h);
4890
4891   return TEST_SUCCESS;
4892 }
4893
4894 /*
4895   We connect to a server which exists, but search for a key that does not exist.
4896 */
4897 static test_return_t memcached_get_by_key_MEMCACHED_NOTFOUND(memcached_st *memc)
4898 {
4899   const char *key= "MemcachedKeyNotEXIST";
4900   size_t len;
4901   uint32_t flags;
4902   memcached_return rc;
4903   char *value;
4904
4905   // See if memcached is reachable.
4906   value= memcached_get_by_key(memc, key, strlen(key), key, strlen(key), &len, &flags, &rc);
4907
4908   test_false(value);
4909   test_true(len == 0);
4910   test_true(rc == MEMCACHED_NOTFOUND);
4911
4912   return TEST_SUCCESS;
4913 }
4914
4915
4916 static test_return_t ketama_compatibility_libmemcached(memcached_st *trash)
4917 {
4918   memcached_return_t rc;
4919   uint64_t value;
4920   int x;
4921   memcached_server_st *server_pool;
4922   memcached_st *memc;
4923
4924   (void)trash;
4925
4926   memc= memcached_create(NULL);
4927   test_true(memc);
4928
4929   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
4930   test_true(rc == MEMCACHED_SUCCESS);
4931
4932   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
4933   test_true(value == 1);
4934
4935   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA) == MEMCACHED_SUCCESS);
4936   test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA);
4937
4938
4939   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");
4940   memcached_server_push(memc, server_pool);
4941
4942   /* verify that the server list was parsed okay. */
4943   test_true(memcached_server_count(memc) == 8);
4944   test_strcmp(server_pool[0].hostname, "10.0.1.1");
4945   test_true(server_pool[0].port == 11211);
4946   test_true(server_pool[0].weight == 600);
4947   test_strcmp(server_pool[2].hostname, "10.0.1.3");
4948   test_true(server_pool[2].port == 11211);
4949   test_true(server_pool[2].weight == 200);
4950   test_strcmp(server_pool[7].hostname, "10.0.1.8");
4951   test_true(server_pool[7].port == 11211);
4952   test_true(server_pool[7].weight == 100);
4953
4954   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
4955    * us test the boundary wraparound.
4956    */
4957   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
4958
4959   /* verify the standard ketama set. */
4960   for (x= 0; x < 99; x++)
4961   {
4962     uint32_t server_idx = memcached_generate_hash(memc, ketama_test_cases[x].key, strlen(ketama_test_cases[x].key));
4963     memcached_server_instance_st instance=
4964       memcached_server_instance_by_position(memc, server_idx);
4965     const char *hostname = memcached_server_name(instance);
4966
4967     test_strcmp(hostname, ketama_test_cases[x].server);
4968   }
4969
4970   memcached_server_list_free(server_pool);
4971   memcached_free(memc);
4972
4973   return TEST_SUCCESS;
4974 }
4975
4976 static test_return_t ketama_compatibility_spymemcached(memcached_st *trash)
4977 {
4978   memcached_return_t rc;
4979   uint64_t value;
4980   memcached_server_st *server_pool;
4981   memcached_st *memc;
4982
4983   (void)trash;
4984
4985   memc= memcached_create(NULL);
4986   test_true(memc);
4987
4988   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED, 1);
4989   test_true(rc == MEMCACHED_SUCCESS);
4990
4991   value= memcached_behavior_get(memc, MEMCACHED_BEHAVIOR_KETAMA_WEIGHTED);
4992   test_true(value == 1);
4993
4994   test_true(memcached_behavior_set_distribution(memc, MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY) == MEMCACHED_SUCCESS);
4995   test_true(memcached_behavior_get_distribution(memc) == MEMCACHED_DISTRIBUTION_CONSISTENT_KETAMA_SPY);
4996
4997   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");
4998   assert(server_pool);
4999   memcached_server_push(memc, server_pool);
5000
5001   /* verify that the server list was parsed okay. */
5002   test_true(memcached_server_count(memc) == 8);
5003   test_strcmp(server_pool[0].hostname, "10.0.1.1");
5004   test_true(server_pool[0].port == 11211);
5005   test_true(server_pool[0].weight == 600);
5006   test_strcmp(server_pool[2].hostname, "10.0.1.3");
5007   test_true(server_pool[2].port == 11211);
5008   test_true(server_pool[2].weight == 200);
5009   test_strcmp(server_pool[7].hostname, "10.0.1.8");
5010   test_true(server_pool[7].port == 11211);
5011   test_true(server_pool[7].weight == 100);
5012
5013   /* VDEAAAAA hashes to fffcd1b5, after the last continuum point, and lets
5014    * us test the boundary wraparound.
5015    */
5016   test_true(memcached_generate_hash(memc, (char *)"VDEAAAAA", 8) == memc->ketama.continuum[0].index);
5017
5018   /* verify the standard ketama set. */
5019   for (uint32_t x= 0; x < 99; x++)
5020   {
5021     uint32_t server_idx= memcached_generate_hash(memc, ketama_test_cases_spy[x].key, strlen(ketama_test_cases_spy[x].key));
5022
5023     memcached_server_instance_st instance=
5024       memcached_server_instance_by_position(memc, server_idx);
5025
5026     const char *hostname= memcached_server_name(instance);
5027
5028     test_strcmp(hostname, ketama_test_cases_spy[x].server);
5029   }
5030
5031   memcached_server_list_free(server_pool);
5032   memcached_free(memc);
5033
5034   return TEST_SUCCESS;
5035 }
5036
5037 static test_return_t regression_bug_434484(memcached_st *memc)
5038 {
5039   test_return_t test_rc;
5040   test_rc= pre_binary(memc);
5041
5042   if (test_rc != TEST_SUCCESS)
5043     return test_rc;
5044
5045   const char *key= "regression_bug_434484";
5046   size_t keylen= strlen(key);
5047
5048   memcached_return_t ret= memcached_append(memc, key, keylen, key, keylen, 0, 0);
5049   test_true(ret == MEMCACHED_NOTSTORED);
5050
5051   size_t size= 2048 * 1024;
5052   char *data= (char*)calloc(1, size);
5053   test_true(data);
5054   ret= memcached_set(memc, key, keylen, data, size, 0, 0);
5055   test_true(ret == MEMCACHED_E2BIG);
5056   free(data);
5057
5058   return TEST_SUCCESS;
5059 }
5060
5061 static test_return_t regression_bug_434843(memcached_st *memc)
5062 {
5063   test_return_t test_rc;
5064   test_rc= pre_binary(memc);
5065
5066   if (test_rc != TEST_SUCCESS)
5067     return test_rc;
5068
5069   memcached_return_t rc;
5070   size_t counter= 0;
5071   memcached_execute_fn callbacks[]= { &callback_counter };
5072
5073   /*
5074    * I only want to hit only _one_ server so I know the number of requests I'm
5075    * sending in the pipleine to the server. Let's try to do a multiget of
5076    * 1024 (that should satisfy most users don't you think?). Future versions
5077    * will include a mget_execute function call if you need a higher number.
5078    */
5079   uint32_t number_of_hosts= memcached_server_count(memc);
5080   memc->number_of_hosts= 1;
5081   const size_t max_keys= 1024;
5082   char **keys= (char**)calloc(max_keys, sizeof(char*));
5083   size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
5084
5085   for (size_t x= 0; x < max_keys; ++x)
5086   {
5087      char k[251];
5088
5089      key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5090      keys[x]= strdup(k);
5091      test_true(keys[x] != NULL);
5092   }
5093
5094   /*
5095    * Run two times.. the first time we should have 100% cache miss,
5096    * and the second time we should have 100% cache hits
5097    */
5098   for (size_t y= 0; y < 2; y++)
5099   {
5100     rc= memcached_mget(memc, (const char**)keys, key_length, max_keys);
5101     test_true(rc == MEMCACHED_SUCCESS);
5102     rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5103
5104     if (y == 0)
5105     {
5106       /* The first iteration should give me a 100% cache miss. verify that*/
5107       char blob[1024]= { 0 };
5108
5109       test_true(counter == 0);
5110
5111       for (size_t x= 0; x < max_keys; ++x)
5112       {
5113         rc= memcached_add(memc, keys[x], key_length[x],
5114                           blob, sizeof(blob), 0, 0);
5115         test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5116       }
5117     }
5118     else
5119     {
5120       /* Verify that we received all of the key/value pairs */
5121        test_true(counter == max_keys);
5122     }
5123   }
5124
5125   /* Release allocated resources */
5126   for (size_t x= 0; x < max_keys; ++x)
5127   {
5128     free(keys[x]);
5129   }
5130   free(keys);
5131   free(key_length);
5132
5133   memc->number_of_hosts= number_of_hosts;
5134
5135   return TEST_SUCCESS;
5136 }
5137
5138 static test_return_t regression_bug_434843_buffered(memcached_st *memc)
5139 {
5140   memcached_return_t rc;
5141   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1);
5142   test_true(rc == MEMCACHED_SUCCESS);
5143
5144   return regression_bug_434843(memc);
5145 }
5146
5147 static test_return_t regression_bug_421108(memcached_st *memc)
5148 {
5149   memcached_return_t rc;
5150   memcached_stat_st *memc_stat= memcached_stat(memc, NULL, &rc);
5151   test_true(rc == MEMCACHED_SUCCESS);
5152
5153   char *bytes= memcached_stat_get_value(memc, memc_stat, "bytes", &rc);
5154   test_true(rc == MEMCACHED_SUCCESS);
5155   test_true(bytes != NULL);
5156   char *bytes_read= memcached_stat_get_value(memc, memc_stat,
5157                                              "bytes_read", &rc);
5158   test_true(rc == MEMCACHED_SUCCESS);
5159   test_true(bytes_read != NULL);
5160
5161   char *bytes_written= memcached_stat_get_value(memc, memc_stat,
5162                                                 "bytes_written", &rc);
5163   test_true(rc == MEMCACHED_SUCCESS);
5164   test_true(bytes_written != NULL);
5165
5166   test_true(strcmp(bytes, bytes_read) != 0);
5167   test_true(strcmp(bytes, bytes_written) != 0);
5168
5169   /* Release allocated resources */
5170   free(bytes);
5171   free(bytes_read);
5172   free(bytes_written);
5173   memcached_stat_free(NULL, memc_stat);
5174
5175   return TEST_SUCCESS;
5176 }
5177
5178 /*
5179  * The test case isn't obvious so I should probably document why
5180  * it works the way it does. Bug 442914 was caused by a bug
5181  * in the logic in memcached_purge (it did not handle the case
5182  * where the number of bytes sent was equal to the watermark).
5183  * In this test case, create messages so that we hit that case
5184  * and then disable noreply mode and issue a new command to
5185  * verify that it isn't stuck. If we change the format for the
5186  * delete command or the watermarks, we need to update this
5187  * test....
5188  */
5189 static test_return_t regression_bug_442914(memcached_st *memc)
5190 {
5191   memcached_return_t rc;
5192   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1);
5193   test_true(rc == MEMCACHED_SUCCESS);
5194   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5195
5196   uint32_t number_of_hosts= memcached_server_count(memc);
5197   memc->number_of_hosts= 1;
5198
5199   char k[250];
5200   size_t len;
5201
5202   for (uint32_t x= 0; x < 250; ++x)
5203   {
5204      len= (size_t)snprintf(k, sizeof(k), "%0250u", x);
5205      rc= memcached_delete(memc, k, len, 0);
5206      test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5207   }
5208
5209   (void)snprintf(k, sizeof(k), "%037u", 251U);
5210   len= strlen(k);
5211
5212   rc= memcached_delete(memc, k, len, 0);
5213   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5214
5215   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0);
5216   test_true(rc == MEMCACHED_SUCCESS);
5217   rc= memcached_delete(memc, k, len, 0);
5218   test_true(rc == MEMCACHED_NOTFOUND);
5219
5220   memc->number_of_hosts= number_of_hosts;
5221
5222   return TEST_SUCCESS;
5223 }
5224
5225 static test_return_t regression_bug_447342(memcached_st *memc)
5226 {
5227   memcached_server_instance_st instance_one;
5228   memcached_server_instance_st instance_two;
5229
5230   if (memcached_server_count(memc) < 3 || pre_replication(memc) != TEST_SUCCESS)
5231     return TEST_SKIPPED;
5232
5233   memcached_return_t rc;
5234
5235   rc= memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NUMBER_OF_REPLICAS, 2);
5236   test_true(rc == MEMCACHED_SUCCESS);
5237
5238   const size_t max_keys= 100;
5239   char **keys= (char**)calloc(max_keys, sizeof(char*));
5240   size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
5241
5242   for (size_t x= 0; x < max_keys; ++x)
5243   {
5244     char k[251];
5245
5246     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5247     keys[x]= strdup(k);
5248     test_true(keys[x] != NULL);
5249     rc= memcached_set(memc, k, key_length[x], k, key_length[x], 0, 0);
5250     test_true(rc == MEMCACHED_SUCCESS);
5251   }
5252
5253   /*
5254   ** We are using the quiet commands to store the replicas, so we need
5255   ** to ensure that all of them are processed before we can continue.
5256   ** In the test we go directly from storing the object to trying to
5257   ** receive the object from all of the different servers, so we
5258   ** could end up in a race condition (the memcached server hasn't yet
5259   ** processed the quiet command from the replication set when it process
5260   ** the request from the other client (created by the clone)). As a
5261   ** workaround for that we call memcached_quit to send the quit command
5262   ** to the server and wait for the response ;-) If you use the test code
5263   ** as an example for your own code, please note that you shouldn't need
5264   ** to do this ;-)
5265   */
5266   memcached_quit(memc);
5267
5268   /* Verify that all messages are stored, and we didn't stuff too much
5269    * into the servers
5270    */
5271   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5272   test_true(rc == MEMCACHED_SUCCESS);
5273
5274   size_t counter= 0;
5275   memcached_execute_fn callbacks[]= { &callback_counter };
5276   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5277   /* Verify that we received all of the key/value pairs */
5278   test_true(counter == max_keys);
5279
5280   memcached_quit(memc);
5281   /*
5282    * Don't do the following in your code. I am abusing the internal details
5283    * within the library, and this is not a supported interface.
5284    * This is to verify correct behavior in the library. Fake that two servers
5285    * are dead..
5286    */
5287   instance_one= memcached_server_instance_by_position(memc, 0);
5288   instance_two= memcached_server_instance_by_position(memc, 2);
5289   in_port_t port0= instance_one->port;
5290   in_port_t port2= instance_two->port;
5291
5292   ((memcached_server_write_instance_st)instance_one)->port= 0;
5293   ((memcached_server_write_instance_st)instance_two)->port= 0;
5294
5295   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5296   test_true(rc == MEMCACHED_SUCCESS);
5297
5298   counter= 0;
5299   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5300   test_true(counter == (unsigned int)max_keys);
5301
5302   /* restore the memc handle */
5303   ((memcached_server_write_instance_st)instance_one)->port= port0;
5304   ((memcached_server_write_instance_st)instance_two)->port= port2;
5305
5306   memcached_quit(memc);
5307
5308   /* Remove half of the objects */
5309   for (size_t x= 0; x < max_keys; ++x)
5310   {
5311     if (x & 1)
5312     {
5313       rc= memcached_delete(memc, keys[x], key_length[x], 0);
5314       test_true(rc == MEMCACHED_SUCCESS);
5315     }
5316   }
5317
5318   memcached_quit(memc);
5319   ((memcached_server_write_instance_st)instance_one)->port= 0;
5320   ((memcached_server_write_instance_st)instance_two)->port= 0;
5321
5322   /* now retry the command, this time we should have cache misses */
5323   rc= memcached_mget(memc, (const char* const *)keys, key_length, max_keys);
5324   test_true(rc == MEMCACHED_SUCCESS);
5325
5326   counter= 0;
5327   rc= memcached_fetch_execute(memc, callbacks, (void *)&counter, 1);
5328   test_true(counter == (unsigned int)(max_keys >> 1));
5329
5330   /* Release allocated resources */
5331   for (size_t x= 0; x < max_keys; ++x)
5332   {
5333     free(keys[x]);
5334   }
5335   free(keys);
5336   free(key_length);
5337
5338   /* restore the memc handle */
5339   ((memcached_server_write_instance_st)instance_one)->port= port0;
5340   ((memcached_server_write_instance_st)instance_two)->port= port2;
5341
5342   return TEST_SUCCESS;
5343 }
5344
5345 static test_return_t regression_bug_463297(memcached_st *memc)
5346 {
5347   memcached_st *memc_clone= memcached_clone(NULL, memc);
5348   test_true(memc_clone != NULL);
5349   test_true(memcached_version(memc_clone) == MEMCACHED_SUCCESS);
5350
5351   memcached_server_instance_st instance=
5352     memcached_server_instance_by_position(memc_clone, 0);
5353
5354   if (instance->major_version > 1 ||
5355       (instance->major_version == 1 &&
5356        instance->minor_version > 2))
5357   {
5358     /* Binary protocol doesn't support deferred delete */
5359     memcached_st *bin_clone= memcached_clone(NULL, memc);
5360     test_true(bin_clone != NULL);
5361     test_true(memcached_behavior_set(bin_clone, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1) == MEMCACHED_SUCCESS);
5362     test_true(memcached_delete(bin_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5363     memcached_free(bin_clone);
5364
5365     memcached_quit(memc_clone);
5366
5367     /* If we know the server version, deferred delete should fail
5368      * with invalid arguments */
5369     test_true(memcached_delete(memc_clone, "foo", 3, 1) == MEMCACHED_INVALID_ARGUMENTS);
5370
5371     /* If we don't know the server version, we should get a protocol error */
5372     memcached_return_t rc= memcached_delete(memc, "foo", 3, 1);
5373
5374     /* but there is a bug in some of the memcached servers (1.4) that treats
5375      * the counter as noreply so it doesn't send the proper error message
5376      */
5377     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5378
5379     /* And buffered mode should be disabled and we should get protocol error */
5380     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 1) == MEMCACHED_SUCCESS);
5381     rc= memcached_delete(memc, "foo", 3, 1);
5382     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5383
5384     /* Same goes for noreply... */
5385     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 1) == MEMCACHED_SUCCESS);
5386     rc= memcached_delete(memc, "foo", 3, 1);
5387     test_true_got(rc == MEMCACHED_PROTOCOL_ERROR || rc == MEMCACHED_NOTFOUND || rc == MEMCACHED_CLIENT_ERROR || rc == MEMCACHED_INVALID_ARGUMENTS, memcached_strerror(NULL, rc));
5388
5389     /* but a normal request should go through (and be buffered) */
5390     test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_BUFFERED);
5391     test_true(memcached_flush_buffers(memc) == MEMCACHED_SUCCESS);
5392
5393     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BUFFER_REQUESTS, 0) == MEMCACHED_SUCCESS);
5394     /* unbuffered noreply should be success */
5395     test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_SUCCESS);
5396     /* unbuffered with reply should be not found... */
5397     test_true(memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NOREPLY, 0) == MEMCACHED_SUCCESS);
5398     test_true(memcached_delete(memc, "foo", 3, 0) == MEMCACHED_NOTFOUND);
5399   }
5400
5401   memcached_free(memc_clone);
5402   return TEST_SUCCESS;
5403 }
5404
5405
5406 /* Test memcached_server_get_last_disconnect
5407  * For a working server set, shall be NULL
5408  * For a set of non existing server, shall not be NULL
5409  */
5410 static test_return_t test_get_last_disconnect(memcached_st *memc)
5411 {
5412   memcached_return_t rc;
5413   memcached_server_instance_st disconnected_server;
5414
5415   /* With the working set of server */
5416   const char *key= "marmotte";
5417   const char *value= "milka";
5418
5419   memcached_reset_last_disconnected_server(memc);
5420   rc= memcached_set(memc, key, strlen(key),
5421                     value, strlen(value),
5422                     (time_t)0, (uint32_t)0);
5423   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5424
5425   disconnected_server = memcached_server_get_last_disconnect(memc);
5426   test_true(disconnected_server == NULL);
5427
5428   /* With a non existing server */
5429   memcached_st *mine;
5430   memcached_server_st *servers;
5431
5432   const char *server_list= "localhost:9";
5433
5434   servers= memcached_servers_parse(server_list);
5435   test_true(servers);
5436   mine= memcached_create(NULL);
5437   rc= memcached_server_push(mine, servers);
5438   test_true(rc == MEMCACHED_SUCCESS);
5439   memcached_server_list_free(servers);
5440   test_true(mine);
5441
5442   rc= memcached_set(mine, key, strlen(key),
5443                     value, strlen(value),
5444                     (time_t)0, (uint32_t)0);
5445   test_true(rc != MEMCACHED_SUCCESS);
5446
5447   disconnected_server= memcached_server_get_last_disconnect(mine);
5448   if (disconnected_server == NULL)
5449   {
5450     fprintf(stderr, "RC %s\n", memcached_strerror(mine, rc));
5451     abort();
5452   }
5453   test_true(disconnected_server != NULL);
5454   test_true(memcached_server_port(disconnected_server)== 9);
5455   test_true(strncmp(memcached_server_name(disconnected_server),"localhost",9) == 0);
5456
5457   memcached_quit(mine);
5458   memcached_free(mine);
5459
5460   return TEST_SUCCESS;
5461 }
5462
5463 static test_return_t test_verbosity(memcached_st *memc)
5464 {
5465   memcached_verbosity(memc, 3);
5466
5467   return TEST_SUCCESS;
5468 }
5469
5470 static test_return_t test_server_failure(memcached_st *memc)
5471 {
5472   memcached_st *local_memc;
5473   memcached_server_instance_st instance= memcached_server_instance_by_position(memc, 0);
5474
5475   local_memc= memcached_create(NULL);
5476
5477   memcached_server_add(local_memc, memcached_server_name(instance), memcached_server_port(instance));
5478   memcached_behavior_set(local_memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 2);
5479
5480   uint32_t server_count= memcached_server_count(local_memc);
5481
5482   test_true(server_count == 1);
5483
5484   // Disable the server
5485   instance= memcached_server_instance_by_position(local_memc, 0);
5486   ((memcached_server_write_instance_st)instance)->server_failure_counter= 2;
5487
5488   memcached_return_t rc;
5489   rc= memcached_set(local_memc, "foo", strlen("foo"),
5490                     NULL, 0,
5491                     (time_t)0, (uint32_t)0);
5492   test_true(rc == MEMCACHED_SERVER_MARKED_DEAD);
5493
5494   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5495   rc= memcached_set(local_memc, "foo", strlen("foo"),
5496                     NULL, 0,
5497                     (time_t)0, (uint32_t)0);
5498   test_true(rc == MEMCACHED_SUCCESS);
5499
5500
5501   memcached_free(local_memc);
5502
5503   return TEST_SUCCESS;
5504 }
5505
5506 static test_return_t test_cull_servers(memcached_st *memc)
5507 {
5508   uint32_t count = memcached_server_count(memc);
5509
5510   // Do not do this in your code, it is not supported.
5511   memc->servers[1].options.is_dead= true;
5512   memc->state.is_time_for_rebuild= true;
5513
5514   uint32_t new_count= memcached_server_count(memc);
5515   test_true(count == new_count);
5516
5517 #if 0
5518   test_true(count == new_count + 1 );
5519 #endif
5520
5521   return TEST_SUCCESS;
5522 }
5523
5524
5525 static memcached_return_t stat_printer(memcached_server_instance_st server,
5526                                        const char *key, size_t key_length,
5527                                        const char *value, size_t value_length,
5528                                        void *context)
5529 {
5530   (void)server;
5531   (void)context;
5532   (void)key;
5533   (void)key_length;
5534   (void)value;
5535   (void)value_length;
5536
5537   return MEMCACHED_SUCCESS;
5538 }
5539
5540 static test_return_t memcached_stat_execute_test(memcached_st *memc)
5541 {
5542   memcached_return_t rc= memcached_stat_execute(memc, NULL, stat_printer, NULL);
5543   test_true(rc == MEMCACHED_SUCCESS);
5544
5545   rc= memcached_stat_execute(memc, "slabs", stat_printer, NULL);
5546   test_true(rc == MEMCACHED_SUCCESS);
5547
5548   rc= memcached_stat_execute(memc, "items", stat_printer, NULL);
5549   test_true(rc == MEMCACHED_SUCCESS);
5550
5551   rc= memcached_stat_execute(memc, "sizes", stat_printer, NULL);
5552   test_true(rc == MEMCACHED_SUCCESS);
5553
5554   return TEST_SUCCESS;
5555 }
5556
5557 /*
5558  * This test ensures that the failure counter isn't incremented during
5559  * normal termination of the memcached instance.
5560  */
5561 static test_return_t wrong_failure_counter_test(memcached_st *memc)
5562 {
5563   memcached_return_t rc;
5564   memcached_server_instance_st instance;
5565
5566   /* Set value to force connection to the server */
5567   const char *key= "marmotte";
5568   const char *value= "milka";
5569
5570   /*
5571    * Please note that I'm abusing the internal structures in libmemcached
5572    * in a non-portable way and you shouldn't be doing this. I'm only
5573    * doing this in order to verify that the library works the way it should
5574    */
5575   uint32_t number_of_hosts= memcached_server_count(memc);
5576   memc->number_of_hosts= 1;
5577
5578   /* Ensure that we are connected to the server by setting a value */
5579   rc= memcached_set(memc, key, strlen(key),
5580                     value, strlen(value),
5581                     (time_t)0, (uint32_t)0);
5582   test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED);
5583
5584
5585   instance= memcached_server_instance_by_position(memc, 0);
5586   /* The test is to see that the memcached_quit doesn't increase the
5587    * the server failure conter, so let's ensure that it is zero
5588    * before sending quit
5589    */
5590   ((memcached_server_write_instance_st)instance)->server_failure_counter= 0;
5591
5592   memcached_quit(memc);
5593
5594   /* Verify that it memcached_quit didn't increment the failure counter
5595    * Please note that this isn't bullet proof, because an error could
5596    * occur...
5597    */
5598   test_true(instance->server_failure_counter == 0);
5599
5600   /* restore the instance */
5601   memc->number_of_hosts= number_of_hosts;
5602
5603   return TEST_SUCCESS;
5604 }
5605
5606 /*
5607  * This tests ensures expected disconnections (for some behavior changes
5608  * for instance) do not wrongly increase failure counter
5609  */
5610 static test_return_t wrong_failure_counter_two_test(memcached_st *memc)
5611 {
5612   memcached_return rc;
5613
5614   memcached_st *memc_clone;
5615   memc_clone= memcached_clone(NULL, memc);
5616   test_true(memc_clone);
5617
5618   /* Set value to force connection to the server */
5619   const char *key= "marmotte";
5620   const char *value= "milka";
5621   char *string = NULL;
5622   size_t string_length;
5623   uint32_t flags;
5624
5625   rc= memcached_set(memc_clone, key, strlen(key),
5626                     value, strlen(value),
5627                     (time_t)0, (uint32_t)0);
5628   test_true_got(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED, memcached_strerror(NULL, rc));
5629
5630
5631   /* put failure limit to 1 */
5632   rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
5633   assert(rc == MEMCACHED_SUCCESS);
5634
5635   /* Put a retry timeout to effectively activate failure_limit effect */
5636   rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1);
5637   assert(rc == MEMCACHED_SUCCESS);
5638
5639   /* change behavior that triggers memcached_quit()*/
5640   rc= memcached_behavior_set(memc_clone, MEMCACHED_BEHAVIOR_TCP_NODELAY, 1);
5641   assert(rc == MEMCACHED_SUCCESS);
5642
5643
5644   /* Check if we still are connected */
5645   string= memcached_get(memc_clone, key, strlen(key),
5646                         &string_length, &flags, &rc);
5647
5648   test_true_got(rc == MEMCACHED_SUCCESS, memcached_strerror(NULL, rc));
5649   test_true(string);
5650   free(string);
5651   memcached_free(memc_clone);
5652
5653   return TEST_SUCCESS;
5654 }
5655
5656
5657
5658
5659 /*
5660  * Test that ensures mget_execute does not end into recursive calls that finally fails
5661  */
5662 static test_return_t regression_bug_490486(memcached_st *memc)
5663 {
5664   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
5665   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_NO_BLOCK, 1);
5666   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
5667   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 1);
5668   memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 3600);
5669
5670 #ifdef __APPLE__
5671   return TEST_SKIPPED; // My MAC can't handle this test
5672 #endif
5673
5674   /*
5675    * I only want to hit _one_ server so I know the number of requests I'm
5676    * sending in the pipeline.
5677    */
5678   uint32_t number_of_hosts= memc->number_of_hosts;
5679   memc->number_of_hosts= 1;
5680   size_t max_keys= 20480;
5681
5682
5683   char **keys= (char **)calloc(max_keys, sizeof(char*));
5684   size_t *key_length= (size_t *)calloc(max_keys, sizeof(size_t));
5685
5686   /* First add all of the items.. */
5687   bool slept= false;
5688   char blob[1024]= { 0 };
5689   memcached_return rc;
5690   for (size_t x= 0; x < max_keys; ++x)
5691   {
5692     char k[251];
5693     key_length[x]= (size_t)snprintf(k, sizeof(k), "0200%lu", (unsigned long)x);
5694     keys[x]= strdup(k);
5695     assert(keys[x] != NULL);
5696     rc= memcached_set(memc, keys[x], key_length[x], blob, sizeof(blob), 0, 0);
5697 #ifdef __APPLE__
5698     if (rc == MEMCACHED_SERVER_MARKED_DEAD)
5699     {
5700       break; // We are out of business
5701     }
5702 #endif
5703     test_true(rc == MEMCACHED_SUCCESS || rc == MEMCACHED_BUFFERED || rc == MEMCACHED_TIMEOUT); // MEMCACHED_TIMEOUT <-- only observed on OSX
5704
5705     if (rc == MEMCACHED_TIMEOUT && slept == false)
5706     {
5707       x++;
5708       sleep(1);// We will try to sleep
5709       slept= true;
5710     }
5711     else if (rc == MEMCACHED_TIMEOUT && slept == true)
5712     {
5713       // We failed to send everything.
5714       break;
5715     }
5716   }
5717
5718   if (rc != MEMCACHED_SERVER_MARKED_DEAD)
5719   {
5720
5721     /* Try to get all of them with a large multiget */
5722     size_t counter= 0;
5723     memcached_execute_function callbacks[]= { &callback_counter };
5724     rc= memcached_mget_execute(memc, (const char**)keys, key_length,
5725                                (size_t)max_keys, callbacks, &counter, 1);
5726
5727     assert(rc == MEMCACHED_SUCCESS);
5728     char* the_value= NULL;
5729     char the_key[MEMCACHED_MAX_KEY];
5730     size_t the_key_length;
5731     size_t the_value_length;
5732     uint32_t the_flags;
5733
5734     do {
5735       the_value= memcached_fetch(memc, the_key, &the_key_length, &the_value_length, &the_flags, &rc);
5736
5737       if ((the_value!= NULL) && (rc == MEMCACHED_SUCCESS))
5738       {
5739         ++counter;
5740         free(the_value);
5741       }
5742
5743     } while ( (the_value!= NULL) && (rc == MEMCACHED_SUCCESS));
5744
5745
5746     assert(rc == MEMCACHED_END);
5747
5748     /* Verify that we got all of the items */
5749     assert(counter == max_keys);
5750   }
5751
5752   /* Release all allocated resources */
5753   for (size_t x= 0; x < max_keys; ++x)
5754   {
5755     free(keys[x]);
5756   }
5757   free(keys);
5758   free(key_length);
5759
5760   memc->number_of_hosts= number_of_hosts;
5761
5762   return TEST_SUCCESS;
5763 }
5764
5765 static test_return_t regression_bug_583031(memcached_st *unused)
5766 {
5767   (void)unused;
5768
5769     memcached_st *memc= memcached_create(NULL);
5770     assert(memc);
5771     memcached_server_add(memc, "10.2.3.4", 11211);
5772
5773     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_CONNECT_TIMEOUT, 1000);
5774     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RETRY_TIMEOUT, 1000);
5775     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SND_TIMEOUT, 1000);
5776     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_RCV_TIMEOUT, 1000);
5777     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_POLL_TIMEOUT, 1000);
5778     memcached_behavior_set(memc, MEMCACHED_BEHAVIOR_SERVER_FAILURE_LIMIT, 3);
5779
5780     memcached_return_t rc;
5781     size_t length;
5782     uint32_t flags;
5783
5784     (void)memcached_get(memc, "dsf", 3, &length, &flags, &rc);
5785
5786     test_true_got(rc == MEMCACHED_TIMEOUT || rc == MEMCACHED_ERRNO || rc == MEMCACHED_FAILURE, memcached_strerror(memc, rc));
5787
5788     memcached_free(memc);
5789
5790     return TEST_SUCCESS;
5791 }
5792
5793 static test_return_t regression_bug_581030(memcached_st *unused)
5794 {
5795   (void)unused;
5796
5797 #ifndef DEBUG
5798   memcached_stat_st *local_stat= memcached_stat(NULL, NULL, NULL);
5799   test_false(local_stat);
5800
5801   memcached_stat_free(NULL, NULL);
5802 #endif
5803
5804   return TEST_SUCCESS;
5805 }
5806
5807 static void memcached_die(memcached_st* mc, memcached_return error, const char* what, uint32_t it)
5808 {
5809   fprintf(stderr, "Iteration #%u: ", it);
5810
5811   if(error == MEMCACHED_ERRNO)
5812   {
5813     fprintf(stderr, "system error %d from %s: %s\n",
5814             errno, what, strerror(errno));
5815   }
5816   else
5817   {
5818     fprintf(stderr, "error %d from %s: %s\n", error, what,
5819             memcached_strerror(mc, error));
5820   }
5821 }
5822
5823 #define TEST_CONSTANT_CREATION 200
5824
5825 static test_return_t regression_bug_(memcached_st *memc)
5826 {
5827   const char *remote_server;
5828   (void)memc;
5829
5830   if (! (remote_server= getenv("LIBMEMCACHED_REMOTE_SERVER")))
5831   {
5832     return TEST_SKIPPED;
5833   }
5834
5835   for (uint32_t x= 0; x < TEST_CONSTANT_CREATION; x++)
5836   {
5837     memcached_st* mc= memcached_create(NULL);
5838     memcached_return rc;
5839
5840     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_BINARY_PROTOCOL, 1);
5841     if (rc != MEMCACHED_SUCCESS)
5842     {
5843       memcached_die(mc, rc, "memcached_behavior_set", x);
5844     }
5845
5846     rc= memcached_behavior_set(mc, MEMCACHED_BEHAVIOR_CACHE_LOOKUPS, 1);
5847     if (rc != MEMCACHED_SUCCESS)
5848     {
5849       memcached_die(mc, rc, "memcached_behavior_set", x);
5850     }
5851
5852     rc= memcached_server_add(mc, remote_server, 0);
5853     if (rc != MEMCACHED_SUCCESS)
5854     {
5855       memcached_die(mc, rc, "memcached_server_add", x);
5856     }
5857
5858     const char *set_key= "akey";
5859     const size_t set_key_len= strlen(set_key);
5860     const char *set_value= "a value";
5861     const size_t set_value_len= strlen(set_value);
5862
5863     if (rc == MEMCACHED_SUCCESS)
5864     {
5865       if (x > 0)
5866       {
5867         size_t get_value_len;
5868         char *get_value;
5869         uint32_t get_value_flags;
5870
5871         get_value= memcached_get(mc, set_key, set_key_len, &get_value_len,
5872                                  &get_value_flags, &rc);
5873         if (rc != MEMCACHED_SUCCESS)
5874         {
5875           memcached_die(mc, rc, "memcached_get", x);
5876         }
5877         else
5878         {
5879
5880           if (x != 0 &&
5881               (get_value_len != set_value_len
5882                || 0!=strncmp(get_value, set_value, get_value_len)))
5883           {
5884             fprintf(stderr, "Values don't match?\n");
5885             rc= MEMCACHED_FAILURE;
5886           }
5887           free(get_value);
5888         }
5889       }
5890
5891       rc= memcached_set(mc,
5892                         set_key, set_key_len,
5893                         set_value, set_value_len,
5894                         0, /* time */
5895                         0  /* flags */
5896                        );
5897       if (rc != MEMCACHED_SUCCESS)
5898       {
5899         memcached_die(mc, rc, "memcached_set", x);
5900       }
5901     }
5902
5903     memcached_quit(mc);
5904     memcached_free(mc);
5905
5906     if (rc != MEMCACHED_SUCCESS)
5907     {
5908       break;
5909     }
5910   }
5911
5912   return TEST_SUCCESS;
5913 }
5914
5915 /*
5916  * Test that the sasl authentication works. We cannot use the default
5917  * pool of servers, because that would require that all servers we want
5918  * to test supports SASL authentication, and that they use the default
5919  * creds.
5920  */
5921 static test_return_t sasl_auth_test(memcached_st *memc)
5922 {
5923 #ifdef LIBMEMCACHED_WITH_SASL_SUPPORT
5924   memcached_return_t rc;
5925
5926   rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5927   test_true(rc == MEMCACHED_SUCCESS);
5928   test_true((rc= memcached_delete(memc, "foo", 3, 0)) == MEMCACHED_SUCCESS);
5929   test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_SUCCESS);
5930   test_true((rc= memcached_destroy_sasl_auth_data(memc)) == MEMCACHED_FAILURE);
5931   test_true((rc= memcached_destroy_sasl_auth_data(NULL)) == MEMCACHED_FAILURE);
5932   memcached_quit(memc);
5933
5934   rc= memcached_set_sasl_auth_data(memc,
5935                                    getenv("LIBMEMCACHED_TEST_SASL_USERNAME"),
5936                                    getenv("LIBMEMCACHED_TEST_SASL_SERVER"));
5937   test_true(rc == MEMCACHED_SUCCESS);
5938
5939   rc= memcached_set(memc, "foo", 3, "bar", 3, (time_t)0, (uint32_t)0);
5940   test_true(rc == MEMCACHED_AUTH_FAILURE);
5941   test_true(memcached_destroy_sasl_auth_data(memc) == MEMCACHED_SUCCESS);
5942
5943   memcached_quit(memc);
5944   return TEST_SUCCESS;
5945 #else
5946   (void)memc;
5947   return TEST_FAILURE;
5948 #endif
5949 }
5950
5951 /* Clean the server before beginning testing */
5952 test_st tests[] ={
5953   {"util_version", 1, (test_callback_fn)util_version_test },
5954   {"flush", 0, (test_callback_fn)flush_test },
5955   {"init", 0, (test_callback_fn)init_test },
5956   {"allocation", 0, (test_callback_fn)allocation_test },
5957   {"server_list_null_test", 0, (test_callback_fn)server_list_null_test},
5958   {"server_unsort", 0, (test_callback_fn)server_unsort_test},
5959   {"server_sort", 0, (test_callback_fn)server_sort_test},
5960   {"server_sort2", 0, (test_callback_fn)server_sort2_test},
5961   {"memcached_server_remove", 0, (test_callback_fn)memcached_server_remove_test},
5962   {"clone_test", 0, (test_callback_fn)clone_test },
5963   {"connection_test", 0, (test_callback_fn)connection_test},
5964   {"callback_test", 0, (test_callback_fn)callback_test},
5965   {"userdata_test", 0, (test_callback_fn)userdata_test},
5966   {"error", 0, (test_callback_fn)error_test },
5967   {"set", 0, (test_callback_fn)set_test },
5968   {"set2", 0, (test_callback_fn)set_test2 },
5969   {"set3", 0, (test_callback_fn)set_test3 },
5970   {"dump", 1, (test_callback_fn)dump_test},
5971   {"add", 1, (test_callback_fn)add_test },
5972   {"replace", 1, (test_callback_fn)replace_test },
5973   {"delete", 1, (test_callback_fn)delete_test },
5974   {"get", 1, (test_callback_fn)get_test },
5975   {"get2", 0, (test_callback_fn)get_test2 },
5976   {"get3", 0, (test_callback_fn)get_test3 },
5977   {"get4", 0, (test_callback_fn)get_test4 },
5978   {"partial mget", 0, (test_callback_fn)get_test5 },
5979   {"stats_servername", 0, (test_callback_fn)stats_servername_test },
5980   {"increment", 0, (test_callback_fn)increment_test },
5981   {"increment_with_initial", 1, (test_callback_fn)increment_with_initial_test },
5982   {"decrement", 0, (test_callback_fn)decrement_test },
5983   {"decrement_with_initial", 1, (test_callback_fn)decrement_with_initial_test },
5984   {"increment_by_key", 0, (test_callback_fn)increment_by_key_test },
5985   {"increment_with_initial_by_key", 1, (test_callback_fn)increment_with_initial_by_key_test },
5986   {"decrement_by_key", 0, (test_callback_fn)decrement_by_key_test },
5987   {"decrement_with_initial_by_key", 1, (test_callback_fn)decrement_with_initial_by_key_test },
5988   {"quit", 0, (test_callback_fn)quit_test },
5989   {"mget", 1, (test_callback_fn)mget_test },
5990   {"mget_result", 1, (test_callback_fn)mget_result_test },
5991   {"mget_result_alloc", 1, (test_callback_fn)mget_result_alloc_test },
5992   {"mget_result_function", 1, (test_callback_fn)mget_result_function },
5993   {"mget_execute", 1, (test_callback_fn)mget_execute },
5994   {"mget_end", 0, (test_callback_fn)mget_end },
5995   {"get_stats", 0, (test_callback_fn)get_stats },
5996   {"add_host_test", 0, (test_callback_fn)add_host_test },
5997   {"add_host_test_1", 0, (test_callback_fn)add_host_test1 },
5998   {"get_stats_keys", 0, (test_callback_fn)get_stats_keys },
5999   {"version_string_test", 0, (test_callback_fn)version_string_test},
6000   {"bad_key", 1, (test_callback_fn)bad_key_test },
6001   {"memcached_server_cursor", 1, (test_callback_fn)memcached_server_cursor_test },
6002   {"read_through", 1, (test_callback_fn)read_through },
6003   {"delete_through", 1, (test_callback_fn)delete_through },
6004   {"noreply", 1, (test_callback_fn)noreply_test},
6005   {"analyzer", 1, (test_callback_fn)analyzer_test},
6006   {"connectionpool", 1, (test_callback_fn)connection_pool_test },
6007   {"memcached_pool_test", 1, (test_callback_fn)memcached_pool_test },
6008   {"ping", 1, (test_callback_fn)ping_test },
6009   {"test_get_last_disconnect", 1, (test_callback_fn)test_get_last_disconnect},
6010   {"verbosity", 1, (test_callback_fn)test_verbosity},
6011   {"test_server_failure", 1, (test_callback_fn)test_server_failure},
6012   {"cull_servers", 1, (test_callback_fn)test_cull_servers},
6013   {"memcached_stat_execute", 1, (test_callback_fn)memcached_stat_execute_test},
6014   {0, 0, 0}
6015 };
6016
6017 test_st behavior_tests[] ={
6018   {"behavior_test", 0, (test_callback_fn)behavior_test},
6019   {"MEMCACHED_BEHAVIOR_CORK", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_CORK_test},
6020   {"MEMCACHED_BEHAVIOR_TCP_KEEPALIVE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPALIVE_test},
6021   {"MEMCACHED_BEHAVIOR_TCP_KEEPIDLE", 0, (test_callback_fn)MEMCACHED_BEHAVIOR_TCP_KEEPIDLE_test},
6022   {0, 0, 0}
6023 };
6024
6025 test_st basic_tests[] ={
6026   {"init", 1, (test_callback_fn)basic_init_test},
6027   {"clone", 1, (test_callback_fn)basic_clone_test},
6028   {"reset", 1, (test_callback_fn)basic_reset_stack_test},
6029   {"reset heap", 1, (test_callback_fn)basic_reset_heap_test},
6030   {"reset stack clone", 1, (test_callback_fn)basic_reset_stack_clone_test},
6031   {"reset heap clone", 1, (test_callback_fn)basic_reset_heap_clone_test},
6032   {0, 0, 0}
6033 };
6034
6035 test_st regression_binary_vs_block[] ={
6036   {"block add", 1, (test_callback_fn)block_add_regression},
6037   {"binary add", 1, (test_callback_fn)binary_add_regression},
6038   {0, 0, 0}
6039 };
6040
6041 test_st async_tests[] ={
6042   {"add", 1, (test_callback_fn)add_wrapper },
6043   {0, 0, 0}
6044 };
6045
6046 test_st string_tests[] ={
6047   {"string static with null", 0, (test_callback_fn)string_static_null },
6048   {"string alloc with null", 0, (test_callback_fn)string_alloc_null },
6049   {"string alloc with 1K", 0, (test_callback_fn)string_alloc_with_size },
6050   {"string alloc with malloc failure", 0, (test_callback_fn)string_alloc_with_size_toobig },
6051   {"string append", 0, (test_callback_fn)string_alloc_append },
6052   {"string append failure (too big)", 0, (test_callback_fn)string_alloc_append_toobig },
6053   {"string_alloc_append_multiple", 0, (test_callback_fn)string_alloc_append_multiple },
6054   {0, 0, (test_callback_fn)0}
6055 };
6056
6057 test_st result_tests[] ={
6058   {"result static", 0, (test_callback_fn)result_static},
6059   {"result alloc", 0, (test_callback_fn)result_alloc},
6060   {0, 0, (test_callback_fn)0}
6061 };
6062
6063 test_st version_1_2_3[] ={
6064   {"append", 0, (test_callback_fn)append_test },
6065   {"prepend", 0, (test_callback_fn)prepend_test },
6066   {"cas", 0, (test_callback_fn)cas_test },
6067   {"cas2", 0, (test_callback_fn)cas2_test },
6068   {"append_binary", 0, (test_callback_fn)append_binary_test },
6069   {0, 0, (test_callback_fn)0}
6070 };
6071
6072 test_st user_tests[] ={
6073   {"user_supplied_bug1", 0, (test_callback_fn)user_supplied_bug1 },
6074   {"user_supplied_bug2", 0, (test_callback_fn)user_supplied_bug2 },
6075   {"user_supplied_bug3", 0, (test_callback_fn)user_supplied_bug3 },
6076   {"user_supplied_bug4", 0, (test_callback_fn)user_supplied_bug4 },
6077   {"user_supplied_bug5", 1, (test_callback_fn)user_supplied_bug5 },
6078   {"user_supplied_bug6", 1, (test_callback_fn)user_supplied_bug6 },
6079   {"user_supplied_bug7", 1, (test_callback_fn)user_supplied_bug7 },
6080   {"user_supplied_bug8", 1, (test_callback_fn)user_supplied_bug8 },
6081   {"user_supplied_bug9", 1, (test_callback_fn)user_supplied_bug9 },
6082   {"user_supplied_bug10", 1, (test_callback_fn)user_supplied_bug10 },
6083   {"user_supplied_bug11", 1, (test_callback_fn)user_supplied_bug11 },
6084   {"user_supplied_bug12", 1, (test_callback_fn)user_supplied_bug12 },
6085   {"user_supplied_bug13", 1, (test_callback_fn)user_supplied_bug13 },
6086   {"user_supplied_bug14", 1, (test_callback_fn)user_supplied_bug14 },
6087   {"user_supplied_bug15", 1, (test_callback_fn)user_supplied_bug15 },
6088   {"user_supplied_bug16", 1, (test_callback_fn)user_supplied_bug16 },
6089 #if !defined(__sun) && !defined(__OpenBSD__)
6090   /*
6091   ** It seems to be something weird with the character sets..
6092   ** value_fetch is unable to parse the value line (iscntrl "fails"), so I
6093   ** guess I need to find out how this is supposed to work.. Perhaps I need
6094   ** to run the test in a specific locale (I tried zh_CN.UTF-8 without success,
6095   ** so just disable the code for now...).
6096   */
6097   {"user_supplied_bug17", 1, (test_callback_fn)user_supplied_bug17 },
6098 #endif
6099   {"user_supplied_bug18", 1, (test_callback_fn)user_supplied_bug18 },
6100   {"user_supplied_bug19", 1, (test_callback_fn)user_supplied_bug19 },
6101   {"user_supplied_bug20", 1, (test_callback_fn)user_supplied_bug20 },
6102   {"user_supplied_bug21", 1, (test_callback_fn)user_supplied_bug21 },
6103   {"wrong_failure_counter_test", 1, (test_callback_fn)wrong_failure_counter_test},
6104   {"wrong_failure_counter_two_test", 1, (test_callback_fn)wrong_failure_counter_two_test},
6105   {0, 0, (test_callback_fn)0}
6106 };
6107
6108 test_st replication_tests[]= {
6109   {"set", 1, (test_callback_fn)replication_set_test },
6110   {"get", 0, (test_callback_fn)replication_get_test },
6111   {"mget", 0, (test_callback_fn)replication_mget_test },
6112   {"delete", 0, (test_callback_fn)replication_delete_test },
6113   {"rand_mget", 0, (test_callback_fn)replication_randomize_mget_test },
6114   {0, 0, (test_callback_fn)0}
6115 };
6116
6117 /*
6118  * The following test suite is used to verify that we don't introduce
6119  * regression bugs. If you want more information about the bug / test,
6120  * you should look in the bug report at
6121  *   http://bugs.launchpad.net/libmemcached
6122  */
6123 test_st regression_tests[]= {
6124   {"lp:434484", 1, (test_callback_fn)regression_bug_434484 },
6125   {"lp:434843", 1, (test_callback_fn)regression_bug_434843 },
6126   {"lp:434843-buffered", 1, (test_callback_fn)regression_bug_434843_buffered },
6127   {"lp:421108", 1, (test_callback_fn)regression_bug_421108 },
6128   {"lp:442914", 1, (test_callback_fn)regression_bug_442914 },
6129   {"lp:447342", 1, (test_callback_fn)regression_bug_447342 },
6130   {"lp:463297", 1, (test_callback_fn)regression_bug_463297 },
6131   {"lp:490486", 1, (test_callback_fn)regression_bug_490486 },
6132   {"lp:583031", 1, (test_callback_fn)regression_bug_583031 },
6133   {"lp:?", 1, (test_callback_fn)regression_bug_ },
6134   {"lp:728286", 1, (test_callback_fn)regression_bug_728286 },
6135   {"lp:581030", 1, (test_callback_fn)regression_bug_581030 },
6136   {0, 0, (test_callback_fn)0}
6137 };
6138
6139 test_st sasl_auth_tests[]= {
6140   {"sasl_auth", 1, (test_callback_fn)sasl_auth_test },
6141   {0, 0, (test_callback_fn)0}
6142 };
6143
6144 test_st ketama_compatibility[]= {
6145   {"libmemcached", 1, (test_callback_fn)ketama_compatibility_libmemcached },
6146   {"spymemcached", 1, (test_callback_fn)ketama_compatibility_spymemcached },
6147   {0, 0, (test_callback_fn)0}
6148 };
6149
6150 test_st generate_tests[] ={
6151   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6152   {"generate_data", 1, (test_callback_fn)generate_data },
6153   {"get_read", 0, (test_callback_fn)get_read },
6154   {"delete_generate", 0, (test_callback_fn)delete_generate },
6155   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6156   {"delete_buffer", 0, (test_callback_fn)delete_buffer_generate},
6157   {"generate_data", 1, (test_callback_fn)generate_data },
6158   {"mget_read", 0, (test_callback_fn)mget_read },
6159   {"mget_read_result", 0, (test_callback_fn)mget_read_result },
6160   {"mget_read_function", 0, (test_callback_fn)mget_read_function },
6161   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6162   {"generate_large_pairs", 1, (test_callback_fn)generate_large_pairs },
6163   {"generate_data", 1, (test_callback_fn)generate_data },
6164   {"generate_buffer_data", 1, (test_callback_fn)generate_buffer_data },
6165   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6166   {0, 0, (test_callback_fn)0}
6167 };
6168
6169 test_st consistent_tests[] ={
6170   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6171   {"generate_data", 1, (test_callback_fn)generate_data },
6172   {"get_read", 0, (test_callback_fn)get_read_count },
6173   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6174   {0, 0, (test_callback_fn)0}
6175 };
6176
6177 test_st consistent_weighted_tests[] ={
6178   {"generate_pairs", 1, (test_callback_fn)generate_pairs },
6179   {"generate_data", 1, (test_callback_fn)generate_data_with_stats },
6180   {"get_read", 0, (test_callback_fn)get_read_count },
6181   {"cleanup", 1, (test_callback_fn)cleanup_pairs },
6182   {0, 0, (test_callback_fn)0}
6183 };
6184
6185 test_st hsieh_availability[] ={
6186   {"hsieh_avaibility_test", 0, (test_callback_fn)hsieh_avaibility_test},
6187   {0, 0, (test_callback_fn)0}
6188 };
6189
6190 test_st murmur_availability[] ={
6191   {"murmur_avaibility_test", 0, (test_callback_fn)murmur_avaibility_test},
6192   {0, 0, (test_callback_fn)0}
6193 };
6194
6195 #if 0
6196 test_st hash_sanity[] ={
6197   {"hash sanity", 0, (test_callback_fn)hash_sanity_test},
6198   {0, 0, (test_callback_fn)0}
6199 };
6200 #endif
6201
6202 test_st ketama_auto_eject_hosts[] ={
6203   {"auto_eject_hosts", 1, (test_callback_fn)auto_eject_hosts },
6204   {"output_ketama_weighted_keys", 1, (test_callback_fn)output_ketama_weighted_keys },
6205   {0, 0, (test_callback_fn)0}
6206 };
6207
6208 test_st hash_tests[] ={
6209   {"one_at_a_time_run", 0, (test_callback_fn)one_at_a_time_run },
6210   {"md5", 0, (test_callback_fn)md5_run },
6211   {"crc", 0, (test_callback_fn)crc_run },
6212   {"fnv1_64", 0, (test_callback_fn)fnv1_64_run },
6213   {"fnv1a_64", 0, (test_callback_fn)fnv1a_64_run },
6214   {"fnv1_32", 0, (test_callback_fn)fnv1_32_run },
6215   {"fnv1a_32", 0, (test_callback_fn)fnv1a_32_run },
6216   {"hsieh", 0, (test_callback_fn)hsieh_run },
6217   {"murmur", 0, (test_callback_fn)murmur_run },
6218   {"jenkis", 0, (test_callback_fn)jenkins_run },
6219   {"memcached_get_hashkit", 0, (test_callback_fn)memcached_get_hashkit_test },
6220   {0, 0, (test_callback_fn)0}
6221 };
6222
6223 test_st error_conditions[] ={
6224   {"memcached_get(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_MEMCACHED_ERRNO },
6225   {"memcached_get(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_MEMCACHED_NOTFOUND },
6226   {"memcached_get_by_key(MEMCACHED_ERRNO)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_ERRNO },
6227   {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
6228   {"memcached_get_by_key(MEMCACHED_NOTFOUND)", 0, (test_callback_fn)memcached_get_by_key_MEMCACHED_NOTFOUND },
6229   {"memcached_increment(MEMCACHED_NO_SERVERS)", 0, (test_callback_fn)memcached_increment_MEMCACHED_NO_SERVERS },
6230   {0, 0, (test_callback_fn)0}
6231 };
6232
6233
6234 test_st parser_tests[] ={
6235   {"behavior", 0, (test_callback_fn)behavior_parser_test },
6236   {"boolean_options", 0, (test_callback_fn)parser_boolean_options_test },
6237   {"configure_file", 0, (test_callback_fn)memcached_create_with_options_with_filename },
6238   {"distribtions", 0, (test_callback_fn)parser_distribution_test },
6239   {"hash", 0, (test_callback_fn)parser_hash_test },
6240   {"libmemcached_check_configuration", 0, (test_callback_fn)libmemcached_check_configuration_test },
6241   {"libmemcached_check_configuration_with_filename", 0, (test_callback_fn)libmemcached_check_configuration_with_filename_test },
6242   {"number_options", 0, (test_callback_fn)parser_number_options_test },
6243   {"randomly generated options", 0, (test_callback_fn)random_statement_build_test },
6244   {"prefix_key", 0, (test_callback_fn)parser_key_prefix_test },
6245   {"server", 0, (test_callback_fn)server_test },
6246   {"bad server strings", 0, (test_callback_fn)servers_bad_test },
6247   {"server with weights", 0, (test_callback_fn)server_with_weight_test },
6248   {0, 0, (test_callback_fn)0}
6249 };
6250
6251 test_st virtual_bucket_tests[] ={
6252   {"basic", 0, (test_callback_fn)virtual_back_map },
6253   {0, 0, (test_callback_fn)0}
6254 };
6255
6256 collection_st collection[] ={
6257 #if 0
6258   {"hash_sanity", 0, 0, hash_sanity},
6259 #endif
6260   {"basic", 0, 0, basic_tests},
6261   {"hsieh_availability", 0, 0, hsieh_availability},
6262   {"murmur_availability", 0, 0, murmur_availability},
6263   {"block", 0, 0, tests},
6264   {"binary", (test_callback_fn)pre_binary, 0, tests},
6265   {"nonblock", (test_callback_fn)pre_nonblock, 0, tests},
6266   {"nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6267   {"settimer", (test_callback_fn)pre_settimer, 0, tests},
6268   {"md5", (test_callback_fn)pre_md5, 0, tests},
6269   {"crc", (test_callback_fn)pre_crc, 0, tests},
6270   {"hsieh", (test_callback_fn)pre_hsieh, 0, tests},
6271   {"jenkins", (test_callback_fn)pre_jenkins, 0, tests},
6272   {"fnv1_64", (test_callback_fn)pre_hash_fnv1_64, 0, tests},
6273   {"fnv1a_64", (test_callback_fn)pre_hash_fnv1a_64, 0, tests},
6274   {"fnv1_32", (test_callback_fn)pre_hash_fnv1_32, 0, tests},
6275   {"fnv1a_32", (test_callback_fn)pre_hash_fnv1a_32, 0, tests},
6276   {"ketama", (test_callback_fn)pre_behavior_ketama, 0, tests},
6277   {"ketama_auto_eject_hosts", (test_callback_fn)pre_behavior_ketama, 0, ketama_auto_eject_hosts},
6278   {"unix_socket", (test_callback_fn)pre_unix_socket, 0, tests},
6279   {"unix_socket_nodelay", (test_callback_fn)pre_nodelay, 0, tests},
6280   {"poll_timeout", (test_callback_fn)poll_timeout, 0, tests},
6281   {"gets", (test_callback_fn)enable_cas, 0, tests},
6282   {"consistent_crc", (test_callback_fn)enable_consistent_crc, 0, tests},
6283   {"consistent_hsieh", (test_callback_fn)enable_consistent_hsieh, 0, tests},
6284 #ifdef MEMCACHED_ENABLE_DEPRECATED
6285   {"deprecated_memory_allocators", (test_callback_fn)deprecated_set_memory_alloc, 0, tests},
6286 #endif
6287   {"memory_allocators", (test_callback_fn)set_memory_alloc, 0, tests},
6288   {"prefix", (test_callback_fn)set_prefix, 0, tests},
6289   {"sasl_auth", (test_callback_fn)pre_sasl, 0, sasl_auth_tests },
6290   {"sasl", (test_callback_fn)pre_sasl, 0, tests },
6291   {"version_1_2_3", (test_callback_fn)check_for_1_2_3, 0, version_1_2_3},
6292   {"string", 0, 0, string_tests},
6293   {"result", 0, 0, result_tests},
6294   {"async", (test_callback_fn)pre_nonblock, 0, async_tests},
6295   {"async_binary", (test_callback_fn)pre_nonblock_binary, 0, async_tests},
6296   {"user", 0, 0, user_tests},
6297   {"generate", 0, 0, generate_tests},
6298   {"generate_hsieh", (test_callback_fn)pre_hsieh, 0, generate_tests},
6299   {"generate_ketama", (test_callback_fn)pre_behavior_ketama, 0, generate_tests},
6300   {"generate_hsieh_consistent", (test_callback_fn)enable_consistent_hsieh, 0, generate_tests},
6301   {"generate_md5", (test_callback_fn)pre_md5, 0, generate_tests},
6302   {"generate_murmur", (test_callback_fn)pre_murmur, 0, generate_tests},
6303   {"generate_jenkins", (test_callback_fn)pre_jenkins, 0, generate_tests},
6304   {"generate_nonblock", (test_callback_fn)pre_nonblock, 0, generate_tests},
6305   // Too slow
6306   {"generate_corked", (test_callback_fn)pre_cork, 0, generate_tests},
6307   {"generate_corked_and_nonblock", (test_callback_fn)pre_cork_and_nonblock, 0, generate_tests},
6308   {"consistent_not", 0, 0, consistent_tests},
6309   {"consistent_ketama", (test_callback_fn)pre_behavior_ketama, 0, consistent_tests},
6310   {"consistent_ketama_weighted", (test_callback_fn)pre_behavior_ketama_weighted, 0, consistent_weighted_tests},
6311   {"ketama_compat", 0, 0, ketama_compatibility},
6312   {"test_hashes", 0, 0, hash_tests},
6313   {"replication", (test_callback_fn)pre_replication, 0, replication_tests},
6314   {"replication_noblock", (test_callback_fn)pre_replication_noblock, 0, replication_tests},
6315   {"regression", 0, 0, regression_tests},
6316   {"behaviors", 0, 0, behavior_tests},
6317   {"regression_binary_vs_block", (test_callback_fn)key_setup, (test_callback_fn)key_teardown, regression_binary_vs_block},
6318   {"error_conditions", 0, 0, error_conditions},
6319   {"parser", 0, 0, parser_tests},
6320   {"virtual buckets", 0, 0, virtual_bucket_tests},
6321   {0, 0, 0, 0}
6322 };
6323
6324 #include "tests/libmemcached_world.h"
6325
6326 void get_world(world_st *world)
6327 {
6328   world->collections= collection;
6329
6330   world->create= (test_callback_create_fn)world_create;
6331   world->destroy= (test_callback_fn)world_destroy;
6332
6333   world->test.startup= (test_callback_fn)world_test_startup;
6334   world->test.flush= (test_callback_fn)world_flush;
6335   world->test.pre_run= (test_callback_fn)world_pre_run;
6336   world->test.post_run= (test_callback_fn)world_post_run;
6337   world->test.on_error= (test_callback_error_fn)world_on_error;
6338
6339   world->collection.startup= (test_callback_fn)world_container_startup;
6340   world->collection.shutdown= (test_callback_fn)world_container_shutdown;
6341
6342   world->runner= &defualt_libmemcached_runner;
6343 }