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