git.m6w6.name Git - awesomized/libmemcached/blob - tests/mem_functions.c

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