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